Implement setting of mandatory fields when triaging

Author: lbarcziova

beeai/Makefile

@@ -17,6 +17,7 @@ run-beeai-bash:
 run-triage-agent-standalone:
 	$(COMPOSE) -f $(COMPOSE_FILE) run --rm \
 		-e JIRA_ISSUE=$(JIRA_ISSUE) \
+		-e DRY_RUN=$(DRY_RUN) \
 		triage-agent
 
 

beeai/agents/tools/version_mapper.py

@@ -0,0 +1,82 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from beeai_framework.context import RunContext
+from beeai_framework.emitter import Emitter
+from beeai_framework.tools import JSONToolOutput, Tool, ToolRunOptions
+
+
+class VersionMapperInput(BaseModel):
+    major_version: int = Field(description="RHEL major version (e.g., 8, 9, 10)")
+    is_critical: bool = Field(description="Whether this is a most critical issue requiring Z-stream (e.g., privilege escalation, remote code execution, data loss)", default=False)
+
+
+class VersionMapperResult(BaseModel):
+    fix_version: str = Field(description="The appropriate fix version for the given major version and criticality")
+    branch: str = Field(description="The corresponding branch name")
+
+
+class VersionMapperOutput(JSONToolOutput[VersionMapperResult]):
+    pass
+
+
+class VersionMapperTool(Tool[VersionMapperInput, ToolRunOptions, VersionMapperOutput]):
+    """Tool to map RHEL major versions to current development fix versions."""
+
+    name = "map_version"
+    description = "Map RHEL major version to current development fix version (Y-stream or Z-stream for most critical issues only)"
+    input_schema = VersionMapperInput
+
+    def __init__(self, options: dict[str, Any] | None = None) -> None:
+        super().__init__(options)
+
+    def _create_emitter(self) -> Emitter:
+        return Emitter.root().child(
+            namespace=["tool", "version", "mapper"],
+            creator=self,
+        )
+
+    async def _run(
+        self, tool_input: VersionMapperInput, options: ToolRunOptions | None, context: RunContext
+    ) -> VersionMapperOutput:
+        """
+        Map RHEL major version to the appropriate fix version.
+
+        Args:
+            tool_input: Input containing major_version and is_critical
+
+        Returns:
+            VersionMapperOutput with fix_version and branch
+        """
+        major_version = tool_input.major_version
+        is_critical = tool_input.is_critical
+
+        if major_version == 8:
+            fix_version = "rhel-8.10.z"
+        elif major_version == 9:
+            if is_critical:
+                fix_version = "rhel-9.7.z"
+            else:
+                fix_version = "rhel-9.8"
+        elif major_version == 10:
+            if is_critical:
+                fix_version = "rhel-10.1.z"
+            else:
+                fix_version = "rhel-10.2"
+        else:
+            raise ValueError(f"Unsupported RHEL major version: {major_version}. Supported versions: 8, 9, 10")
+
+        branch_map = {
+            8: "c8s",
+            9: "c9s",
+            10: "c10s"
+        }
+        branch = branch_map[major_version]
+
+        result = VersionMapperResult(
+            fix_version=fix_version,
+            branch=branch
+        )
+
+        return VersionMapperOutput(result=result)

beeai/agents/triage_agent.py

@@ -23,6 +23,7 @@
 from observability import setup_observability
 from tools.commands import RunShellCommandTool
 from tools.patch_validator import PatchValidatorTool
+from tools.version_mapper import VersionMapperTool
 from utils import get_agent_execution_config, mcp_tools, redis_client
 
 logger = logging.getLogger(__name__)
@@ -126,6 +127,7 @@ def render_prompt(input: InputSchema) -> str:
          * A Rebase is only to be chosen when the issue explicitly instructs you to "rebase" or "update"
            to a newer/specific upstream version. Do not infer this.
          * Identify the <package_version> the package should be updated or rebased to.
+         * Set the Jira fields as per the instructions below.
 
       2. **Backport a Patch OR Request Clarification**
          This path is for issues that represent a clear bug or CVE that needs a targeted fix.
@@ -183,6 +185,8 @@ def render_prompt(input: InputSchema) -> str:
            is clarification-needed
          * This is the correct choice when you are sure a problem exists but cannot find the solution yourself
 
+         2.5 Set the Jira fields as per the instructions below.
+
       3. **No Action**
          A No Action decision is appropriate for issues that are NOT bugs or CVEs requiring code fixes:
          * QE tasks, testing, or validation work
@@ -197,6 +201,19 @@ def render_prompt(input: InputSchema) -> str:
          * The package mentioned in the issue cannot be found or identified
          * The issue cannot be accessed
 
+      **Final Step: Set JIRA Fields (for Rebase and Backport decisions only)**
+
+         If your decision is rebase or backport, use set_jira_fields tool to update JIRA fields (Severity, Fix Version, Target End):
+         1. Check all of the mentioned fields in the JIRA issue and don't modify those that are already set
+         2. Extract the affected RHEL major version from the JIRA issue (look in Affects Version/s field or issue description)
+         3. Determine if this is a very critical issue requiring Z-stream (only for: privilege escalation, remote code execution, data loss/corruption, or system compromise)
+         4. Use map_version tool with the major version and criticality to get the appropriate Fix Version and branch
+         5. Set JIRA fields:
+             * Severity: default to 'moderate', for important issues use 'important', for most critical use 'critical' (privilege escalation, RCE, data loss)
+             * Fix Version: use the fix_version from map_version tool result
+             * Target End: today + 14 days
+         6. Use the branch from map_version tool result for your output
+
       **Output Format**
 
       Your output must strictly follow the format below.
@@ -242,21 +259,23 @@ async def main() -> None:
     async with mcp_tools(os.getenv("MCP_GATEWAY_URL")) as gateway_tools:
         agent = RequirementAgent(
             llm=ChatModel.from_name(os.getenv("CHAT_MODEL")),
-            tools=[ThinkTool(), RunShellCommandTool(), PatchValidatorTool()]
-            + [t for t in gateway_tools if t.name == "get_jira_details"],
+            tools=[ThinkTool(), RunShellCommandTool(), PatchValidatorTool(), VersionMapperTool()]
+            + [t for t in gateway_tools if t.name in ["get_jira_details", "set_jira_fields"]],
             memory=UnconstrainedMemory(),
             requirements=[
                 ConditionalRequirement(ThinkTool, force_after=Tool, consecutive_allowed=False),
                 ConditionalRequirement("get_jira_details", min_invocations=1),
                 ConditionalRequirement(RunShellCommandTool, only_after="get_jira_details"),
                 ConditionalRequirement(PatchValidatorTool, only_after="get_jira_details"),
+                ConditionalRequirement("set_jira_fields", only_after="get_jira_details"),
             ],
             middlewares=[GlobalTrajectoryMiddleware(pretty=True)],
             role="Red Hat Enterprise Linux developer",
             instructions=[
                 "Use the `think` tool to reason through complex decisions and document your approach.",
                 "Be proactive in your search for fixes and do not give up easily.",
-            ],
+                "After completing your triage analysis, if your decision is backport or rebase, always set appropriate JIRA fields per the instructions using set_jira_fields tool.",
+            ]
         )
 
         async def run(input):

beeai/compose.yaml

@@ -42,6 +42,7 @@ services:
       - KEYTAB_FILE=/home/mcp/keytab
       # default cache location is a keyring
       - KRB5CCNAME=FILE:/tmp/krb5cc
+      - DRY_RUN=${DRY_RUN:-false}
     env_file:
       - .secrets/mcp-gateway.env
     volumes:

beeai/mcp_server/jira_tools.py

@@ -1,3 +1,4 @@
+import datetime
 import os
 import json
 from enum import Enum
@@ -8,6 +9,12 @@
 from pydantic import Field
 
 
+# Jira custom field IDs
+SEVERITY_CUSTOM_FIELD = "customfield_12316142"
+PRELIMINARY_TESTING_CUSTOM_FIELD = "customfield_12321540"
+TARGET_END_CUSTOM_FIELD = "customfield_12313942"
+
+
 class Severity(Enum):
     NONE = "None"
     INFORMATIONAL = "Informational"
@@ -74,26 +81,31 @@ def set_jira_fields(
     issue_key: Annotated[str, Field(description="Jira issue key (e.g. RHEL-12345)")],
     fix_versions: Annotated[
         list[str] | None,
-        Field(
-            description="List of Fix Version/s values",
-            pattern=r"^(CentOS Stream \d+|eln|zstream|rhel-\d+\.\d+(\.(\d+|z)|\.\d+\.z|[._](alpha|beta))?)$",
-        ),
+        Field(description="List of Fix Version/s values (e.g., ['rhel-9.8'], ['rhel-9.7.z'])"),
     ] = None,
     severity: Annotated[Severity | None, Field(description="Severity value")] = None,
     preliminary_testing: Annotated[
         PreliminaryTesting | None, Field(description="Preliminary Testing value")
     ] = None,
+    target_end: Annotated[datetime.date | None, Field(description="Target End value")] = None,
 ) -> str:
     """
     Updates the specified Jira issue, setting the specified fields (if provided).
     """
+    if os.getenv("DRY_RUN", "False").lower() == "true":
+        return "Dry run, not updating Jira fields"
+
+    return "Not updating Jira fields"
+
     fields = {}
     if fix_versions is not None:
         fields["fixVersions"] = [{"name": fv} for fv in fix_versions]
     if severity is not None:
-        fields["customfield_12316142"] = {"value": severity.value}
+        fields[SEVERITY_CUSTOM_FIELD] = {"value": severity.value}
     if preliminary_testing is not None:
-        fields["customfield_12321540"] = {"value": preliminary_testing.value}
+        fields[PRELIMINARY_TESTING_CUSTOM_FIELD] = {"value": preliminary_testing.value}
+    if target_end is not None:
+        fields[TARGET_END_CUSTOM_FIELD] = {"value": target_end.strftime("%Y-%m-%d")}
     if not fields:
         return "No fields to update have been specified, not doing anything"
     try: