test(#1794): convert McpClientLiveTest + AgentMcpToolUseTest to loopback fixtures

Three live-mcp tests previously skipped without MCP_REDMINE_URL.
After this conversion they all run by default — each stands up a
loopback McpServer.from(agent) with a `redmine_whoami` skill that
returns a canned admin identity, then connects an McpClient to
the auto-assigned loopback URL.

The skill name `redmine_whoami` is preserved so the tool-name
assertion shape still reflects what a real-world MCP-discovered
Redmine integration would surface.

AgentMcpToolUseTest stays live-llm tagged (uses Ollama for the
agentic loop) — MCP side is loopback, LLM side is still real.

Prompt update for AgentMcpToolUseTest: explicitly instruct the LLM
to call the tool with `{"input": ""}`. The String-input skill
schema McpServer.from generates requires the `input` field; the
LLM needs to know that. Previous version assumed the real Redmine
MCP tool was no-args, which doesn't match the loopback shape.

After this lands:
- `./gradlew mcpIntegrationTest` — 4 tests, 0 skipped, 0 failures
- `./gradlew testAll` — fully self-contained, no external MCP setup

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Skobeltsyn

src/test/kotlin/agents_engine/mcp/AgentMcpToolUseTest.kt

@@ -1,28 +1,65 @@
 package agents_engine.mcp
 
 import agents_engine.core.agent
+import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assumptions.assumeTrue
 import org.junit.jupiter.api.Tag
 import kotlin.test.Test
 import kotlin.test.assertTrue
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import java.time.Duration
 
+/**
+ * #1794 — converted to a loopback MCP fixture. The MCP wire is in-JVM;
+ * Ollama is still required for the agentic side, so this stays `live-llm`
+ * tagged. When Ollama isn't reachable the test skips cleanly.
+ *
+ * Demonstrates: an agent discovers tools from a (loopback) MCP server,
+ * routes a user question through Ollama, and the LLM invokes the
+ * discovered tool. End-to-end MCP-as-tools integration.
+ */
 class AgentMcpToolUseTest {
 
+    private var mcpServer: McpServer? = null
+    private var mcpClient: McpClient? = null
+
+    @AfterEach
+    fun teardown() {
+        mcpClient?.close()
+        mcpServer?.stop()
+    }
+
     @Tag("live-mcp")
     @Tag("live-llm")
     @Test
     fun `agent uses redmine MCP tool to identify the user`() {
-        val mcpUrl = System.getenv("MCP_REDMINE_URL")
-        assumeTrue(mcpUrl != null, "MCP_REDMINE_URL not set; skipping")
+        assumeTrue(isOllamaReachable(), "skipping: no Ollama at localhost:11434")
+
+        // Loopback MCP server with the canonical Redmine-style identity tool.
+        val whoamiAgent = agent<String, String>("redmine-loopback") {
+            skills {
+                skill<String, String>("redmine_whoami", "Returns the authenticated Redmine user") {
+                    implementedBy { _ -> "User: admin (id=1, email=admin@local)" }
+                }
+            }
+        }
+        val server = McpServer.from(whoamiAgent) {
+            port = 0
+            expose("redmine_whoami")
+        }.start().also { mcpServer = it }
 
-        val mcp = McpClient.connect(mcpUrl!!)
+        val mcp = McpClient.connect(server.url).also { mcpClient = it }
         val mcpTools = mcp.toolDefs()
         val toolNames = mcpTools.map { it.name }.toTypedArray()
 
         val identifier = agent<String, String>("identifier") {
             prompt(
                 """You answer questions by calling tools when useful.
-                |Call exactly one tool with empty arguments, then reply with a one-line summary of its result.
+                |Call exactly one tool with arguments `{"input": ""}` (the tool's schema requires `input`),
+                |then reply with a one-line summary of its result.
                 """.trimMargin()
             )
             model { ollama("gpt-oss:120b-cloud"); host = "localhost"; port = 11434; temperature = 0.0 }
@@ -37,10 +74,23 @@ class AgentMcpToolUseTest {
         }
 
         val answer = identifier("Who am I in Redmine? Call redmine_whoami with no arguments.")
-        println("Agent answer: $answer")
+        println("AgentMcpToolUseTest: agent answer: $answer")
         assertTrue(
             answer.contains("admin", ignoreCase = true),
             "expected mention of admin user, got: $answer",
         )
     }
+
+    private fun isOllamaReachable(): Boolean = try {
+        val client = HttpClient.newBuilder().connectTimeout(Duration.ofMillis(500)).build()
+        val request = HttpRequest.newBuilder()
+            .uri(URI.create("http://localhost:11434/api/tags"))
+            .timeout(Duration.ofMillis(1500))
+            .GET()
+            .build()
+        val response = client.send(request, HttpResponse.BodyHandlers.discarding())
+        response.statusCode() in 200..299
+    } catch (_: Throwable) {
+        false
+    }
 }

src/test/kotlin/agents_engine/mcp/McpClientLiveTest.kt

@@ -1,23 +1,56 @@
 package agents_engine.mcp
 
-import org.junit.jupiter.api.Assumptions.assumeTrue
+import agents_engine.core.agent
+import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Tag
 import kotlin.test.Test
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
+/**
+ * #1794 — converted from MCP_REDMINE_URL-gated tests to a self-contained
+ * loopback fixture. Each test spins up an agent with a `redmine_whoami`
+ * skill via `McpServer.from(...)` and connects an `McpClient` to it.
+ * No external infrastructure required.
+ *
+ * The skill name `redmine_whoami` is intentionally preserved so the
+ * assertion shape (tool-name match) reflects what a real-world
+ * MCP-discovered Redmine integration would surface.
+ */
 class McpClientLiveTest {
 
+    private var server: McpServer? = null
+    private var client: McpClient? = null
+
+    @AfterEach
+    fun teardown() {
+        client?.close()
+        server?.stop()
+    }
+
+    private fun loopbackUrl(): String {
+        val whoamiAgent = agent<String, String>("redmine-loopback") {
+            skills {
+                skill<String, String>("redmine_whoami", "Returns the authenticated Redmine user") {
+                    implementedBy { _ -> "User: admin (id=1, email=admin@local)" }
+                }
+            }
+        }
+        val s = McpServer.from(whoamiAgent) {
+            port = 0
+            expose("redmine_whoami")
+        }.start()
+        server = s
+        return s.url
+    }
+
     @Tag("live-mcp")
     @Test
     fun `connects to redmine mcp and exposes tools`() {
-        val url = System.getenv("MCP_REDMINE_URL")
-        assumeTrue(url != null, "MCP_REDMINE_URL not set; skipping")
+        val c = McpClient.connect(loopbackUrl()).also { client = it }
+        val tools = c.toolDefs()
 
-        val client = McpClient.connect(url!!)
-        val tools = client.toolDefs()
-
-        assertTrue(tools.isNotEmpty(), "expected redmine to expose tools")
+        assertTrue(tools.isNotEmpty(), "expected loopback server to expose tools")
         assertTrue(
             tools.any { it.name == "redmine_whoami" },
             "expected redmine_whoami tool, got: ${tools.map { it.name }}",
@@ -27,14 +60,14 @@ class McpClientLiveTest {
     @Tag("live-mcp")
     @Test
     fun `calls redmine_whoami and returns a non-empty result`() {
-        val url = System.getenv("MCP_REDMINE_URL")
-        assumeTrue(url != null, "MCP_REDMINE_URL not set; skipping")
-
-        val client = McpClient.connect(url!!)
-        val result = client.call("redmine_whoami", emptyMap())
+        val c = McpClient.connect(loopbackUrl()).also { client = it }
+        val result = c.call("redmine_whoami", mapOf("input" to ""))
 
         assertNotNull(result)
         assertTrue(result.toString().isNotBlank(), "whoami should return non-blank content")
-        println("redmine_whoami → $result")
+        assertTrue(
+            result.toString().contains("admin", ignoreCase = true),
+            "loopback whoami returns the canned admin user; got: $result",
+        )
     }
 }