86c44799a6
All checks were successful
Build and Deploy DevOpsDash / build-image (push) Successful in 6s
FastMCP 2.0 streamable HTTP requires Accept: application/json, text/event-stream
and can return text/event-stream responses with data: {...} SSE lines.
139 lines
4.3 KiB
Python
139 lines
4.3 KiB
Python
"""MCP proxy client — calls DevOpsMCP's worklog/standup tools over HTTP MCP protocol.
|
|
|
|
FastMCP 2.0 uses streamable HTTP transport (MCP spec §6.3.3):
|
|
- POST to /mcp with Accept: application/json, text/event-stream
|
|
- Server may respond with JSON or SSE stream (text/event-stream)
|
|
- SSE responses have `data: {...}` lines containing JSON-RPC messages
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from typing import Any, Dict, Optional
|
|
|
|
import httpx
|
|
|
|
MCP_URL = os.environ.get("DEVOPS_MCP_URL", "http://localhost:8000")
|
|
_MCP_ENDPOINT = f"{MCP_URL}/mcp"
|
|
|
|
_HEADERS = {
|
|
"Content-Type": "application/json",
|
|
"Accept": "application/json, text/event-stream",
|
|
}
|
|
|
|
|
|
def _parse_sse_data(text: str) -> Dict[str, Any]:
|
|
"""Extract JSON-RPC result from SSE stream data lines."""
|
|
for line in text.splitlines():
|
|
line = line.strip()
|
|
if line.startswith("data:"):
|
|
chunk = line[5:].strip()
|
|
if not chunk or chunk == "[DONE]":
|
|
continue
|
|
try:
|
|
msg = json.loads(chunk)
|
|
if "result" in msg or "error" in msg:
|
|
return msg
|
|
except json.JSONDecodeError:
|
|
continue
|
|
return {}
|
|
|
|
|
|
def _extract_result(data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Extract tool result content from JSON-RPC response."""
|
|
if "error" in data:
|
|
raise RuntimeError(f"MCP error: {data['error']}")
|
|
result = data.get("result", {})
|
|
content = result.get("content", [])
|
|
if content and isinstance(content[0], dict):
|
|
text = content[0].get("text", "{}")
|
|
try:
|
|
return json.loads(text)
|
|
except json.JSONDecodeError:
|
|
return {"raw": text}
|
|
return result
|
|
|
|
|
|
async def _call_tool(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Call a DevOpsMCP tool via MCP JSON-RPC 2.0 streamable HTTP transport."""
|
|
payload = {
|
|
"jsonrpc": "2.0",
|
|
"method": "tools/call",
|
|
"params": {"name": tool_name, "arguments": arguments},
|
|
"id": 1,
|
|
}
|
|
async with httpx.AsyncClient(timeout=60.0) as client:
|
|
resp = await client.post(_MCP_ENDPOINT, json=payload, headers=_HEADERS)
|
|
resp.raise_for_status()
|
|
|
|
content_type = resp.headers.get("content-type", "")
|
|
if "text/event-stream" in content_type:
|
|
data = _parse_sse_data(resp.text)
|
|
else:
|
|
data = resp.json()
|
|
|
|
return _extract_result(data)
|
|
|
|
|
|
async def get_worklog(
|
|
context: str = "egmont",
|
|
days: int = 7,
|
|
group_by: str = "repo",
|
|
since_date: Optional[str] = None,
|
|
until_date: Optional[str] = None,
|
|
) -> Dict[str, Any]:
|
|
args: Dict[str, Any] = {"context": context, "days": days, "group_by": group_by}
|
|
if since_date:
|
|
args["since_date"] = since_date
|
|
if until_date:
|
|
args["until_date"] = until_date
|
|
return await _call_tool("worklog", args)
|
|
|
|
|
|
async def get_standup(days: int = 2, context: str = "egmont") -> Dict[str, Any]:
|
|
return await _call_tool("generate_standup", {"days": days, "context": context})
|
|
|
|
|
|
async def list_knowledge(category: Optional[str] = None, tag: Optional[str] = None) -> Dict[str, Any]:
|
|
args: Dict[str, Any] = {}
|
|
if category:
|
|
args["category"] = category
|
|
if tag:
|
|
args["tag"] = tag
|
|
return await _call_tool("list_knowledge", args)
|
|
|
|
|
|
async def get_knowledge(storage_filename: str) -> Dict[str, Any]:
|
|
return await _call_tool("get_knowledge", {"storage_filename": storage_filename, "include_metadata": False})
|
|
|
|
|
|
async def list_howtos() -> Dict[str, Any]:
|
|
return await _call_tool("list_howtos", {})
|
|
|
|
|
|
async def get_howto(filename: str) -> Dict[str, Any]:
|
|
return await _call_tool("get_howto_content", {"filename": filename})
|
|
|
|
|
|
async def list_agents(domain: Optional[str] = None) -> Dict[str, Any]:
|
|
args: Dict[str, Any] = {}
|
|
if domain:
|
|
args["domain"] = domain
|
|
return await _call_tool("get_agent", args)
|
|
|
|
|
|
async def get_agent(name: str) -> Dict[str, Any]:
|
|
return await _call_tool("get_agent", {"name": name})
|
|
|
|
|
|
async def list_skills(domain: Optional[str] = None) -> Dict[str, Any]:
|
|
args: Dict[str, Any] = {}
|
|
if domain:
|
|
args["domain"] = domain
|
|
return await _call_tool("get_skill", args)
|
|
|
|
|
|
async def get_skill(name: str) -> Dict[str, Any]:
|
|
return await _call_tool("get_skill", {"name": name})
|