foundry-mcp 0.3.3__py3-none-any.whl → 0.8.10__py3-none-any.whl

foundry_mcp/tools/unified/lifecycle.py

@@ -209,6 +209,7 @@ def _handle_move(
     spec_id: Optional[str] = None,
     to_folder: Optional[str] = None,
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "move"
     request_id = _request_id()
@@ -293,7 +294,9 @@ def _handle_activate(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "activate"
     request_id = _request_id()
@@ -356,6 +359,7 @@ def _handle_complete(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     force: Optional[bool] = False,
     path: Optional[str] = None,
 ) -> dict:
@@ -429,7 +433,9 @@ def _handle_archive(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "archive"
     request_id = _request_id()
@@ -492,7 +498,9 @@ def _handle_state(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "state"
     request_id = _request_id()

foundry_mcp/tools/unified/plan.py

@@ -19,6 +19,7 @@ from foundry_mcp.core.ai_consultation import (
     ConsultationWorkflow,
     ConsensusResult,
 )
+from foundry_mcp.core.llm_config import load_consultation_config
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import get_metrics, mcp_tool
 from foundry_mcp.core.providers import available_providers
@@ -29,6 +30,7 @@ from foundry_mcp.core.responses import (
     error_response,
     success_response,
 )
+from foundry_mcp.core.llm_config import load_consultation_config
 from foundry_mcp.core.security import is_prompt_injection
 from foundry_mcp.core.spec import find_specs_directory
 from foundry_mcp.tools.unified.router import (
@@ -55,6 +57,20 @@ def _extract_plan_name(plan_path: str) -> str:
     return Path(plan_path).stem
 
 
+def _find_config_file(start_path: Path) -> Optional[Path]:
+    """Find foundry-mcp.toml by walking up from start_path."""
+    current = start_path if start_path.is_dir() else start_path.parent
+    for _ in range(10):  # Limit depth to prevent infinite loops
+        config_file = current / "foundry-mcp.toml"
+        if config_file.exists():
+            return config_file
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+    return None
+
+
 def _parse_review_summary(content: str) -> dict:
     """Parse review markdown to extract section counts."""
 
@@ -323,7 +339,10 @@ def perform_plan_review(
     template_id = REVIEW_TYPE_TO_TEMPLATE[review_type]
 
     try:
-        orchestrator = ConsultationOrchestrator()
+        # Load consultation config from workspace to get provider priority list
+        config_file = _find_config_file(plan_file)
+        consultation_config = load_consultation_config(config_file=config_file)
+        orchestrator = ConsultationOrchestrator(config=consultation_config)
         request = ConsultationRequest(
             workflow=ConsultationWorkflow.MARKDOWN_PLAN_REVIEW,
             prompt_id=template_id,
@@ -339,6 +358,7 @@ def perform_plan_review(
 
         consensus_info: Optional[dict] = None
         provider_used: Optional[str] = None
+        provider_reviews: list[dict[str, str]] = []
 
         if isinstance(result, ConsultationResult):
             if not result.success:
@@ -362,16 +382,125 @@ def perform_plan_review(
                         remediation="Check AI provider configuration or try again later",
                     )
                 )
-            review_content = result.primary_content
+
             providers_consulted = [r.provider_id for r in result.responses]
             provider_used = providers_consulted[0] if providers_consulted else "unknown"
+
+            # Extract failed provider details for visibility
+            failed_providers = [
+                {"provider_id": r.provider_id, "error": r.error}
+                for r in result.responses
+                if not r.success
+            ]
+            # Filter for truly successful responses (success=True AND non-empty content)
+            successful_responses = [
+                r for r in result.responses if r.success and r.content.strip()
+            ]
+            successful_providers = [r.provider_id for r in successful_responses]
+
             consensus_info = {
                 "providers_consulted": providers_consulted,
                 "successful": result.agreement.successful_providers
                 if result.agreement
                 else 0,
                 "failed": result.agreement.failed_providers if result.agreement else 0,
+                "successful_providers": successful_providers,
+                "failed_providers": failed_providers,
             }
+
+            # Save individual provider review files and optionally run synthesis
+            if len(successful_responses) >= 2:
+                # Multi-model mode: save per-provider files, then synthesize
+                specs_dir = find_specs_directory()
+                if specs_dir is None:
+                    return asdict(
+                        error_response(
+                            "No specs directory found for storing plan review",
+                            error_code=ErrorCode.NOT_FOUND,
+                            error_type=ErrorType.NOT_FOUND,
+                            remediation="Create a specs/ directory with pending/active/completed/archived subdirectories",
+                        )
+                    )
+
+                plan_reviews_dir = specs_dir / ".plan-reviews"
+                plan_reviews_dir.mkdir(parents=True, exist_ok=True)
+
+                # Save each provider's review to a separate file
+                model_reviews_text = ""
+                for response in successful_responses:
+                    provider_file = (
+                        plan_reviews_dir
+                        / f"{plan_name}-{review_type}-{response.provider_id}.md"
+                    )
+                    provider_file.write_text(response.content, encoding="utf-8")
+                    provider_reviews.append(
+                        {"provider_id": response.provider_id, "path": str(provider_file)}
+                    )
+                    model_reviews_text += (
+                        f"\n---\n## Review by {response.provider_id}\n\n"
+                        f"{response.content}\n"
+                    )
+
+                # Run synthesis call using first provider
+                logger.info(
+                    "Running synthesis for %d provider reviews: %s",
+                    len(successful_responses),
+                    successful_providers,
+                )
+                synthesis_request = ConsultationRequest(
+                    workflow=ConsultationWorkflow.PLAN_REVIEW,
+                    prompt_id="SYNTHESIS_PROMPT_V1",
+                    context={
+                        "spec_id": plan_name,
+                        "title": plan_name,
+                        "num_models": len(successful_responses),
+                        "model_reviews": model_reviews_text,
+                    },
+                    provider_id=successful_providers[0],
+                    timeout=ai_timeout,
+                )
+                try:
+                    synthesis_result = orchestrator.consult(
+                        synthesis_request, use_cache=consultation_cache
+                    )
+                except Exception as e:
+                    logger.error("Synthesis call crashed: %s", e, exc_info=True)
+                    synthesis_result = None
+
+                # Handle both ConsultationResult and ConsensusResult
+                synthesis_success = False
+                synthesis_content = None
+                if synthesis_result:
+                    if isinstance(synthesis_result, ConsultationResult) and synthesis_result.success:
+                        synthesis_content = synthesis_result.content
+                        consensus_info["synthesis_provider"] = synthesis_result.provider_id
+                        synthesis_success = bool(synthesis_content and synthesis_content.strip())
+                    elif isinstance(synthesis_result, ConsensusResult) and synthesis_result.success:
+                        synthesis_content = synthesis_result.primary_content
+                        consensus_info["synthesis_provider"] = synthesis_result.responses[0].provider_id if synthesis_result.responses else "unknown"
+                        synthesis_success = bool(synthesis_content and synthesis_content.strip())
+
+                if synthesis_success and synthesis_content:
+                    review_content = synthesis_content
+                else:
+                    # Synthesis failed - fall back to first provider's content
+                    error_detail = "unknown"
+                    if synthesis_result is None:
+                        error_detail = "synthesis crashed (see logs)"
+                    elif isinstance(synthesis_result, ConsultationResult):
+                        error_detail = synthesis_result.error or "empty response"
+                    elif isinstance(synthesis_result, ConsensusResult):
+                        error_detail = "empty synthesis content"
+                    logger.warning(
+                        "Synthesis call failed (%s), falling back to first provider's content",
+                        error_detail,
+                    )
+                    review_content = result.primary_content
+                    consensus_info["synthesis_failed"] = True
+                    consensus_info["synthesis_error"] = error_detail
+            else:
+                # Single successful provider - use its content directly (no synthesis needed)
+                review_content = result.primary_content
         else:  # pragma: no cover - defensive branch
             logger.error("Unknown consultation result type: %s", type(result))
             return asdict(
@@ -444,6 +573,8 @@ def perform_plan_review(
         "llm_status": llm_status,
         "provider_used": provider_used,
     }
+    if provider_reviews:
+        response_data["provider_reviews"] = provider_reviews
     if consensus_info:
         response_data["consensus"] = consensus_info
 

foundry_mcp/tools/unified/provider.py

@@ -11,7 +11,6 @@ from mcp.server.fastmcp import FastMCP
 
 from foundry_mcp.config import ServerConfig
 from foundry_mcp.core.context import generate_correlation_id, get_correlation_id
-from foundry_mcp.core.feature_flags import FeatureFlag, FlagState, get_flag_service
 from foundry_mcp.core.llm_provider import RateLimitError
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import get_metrics, mcp_tool
@@ -42,19 +41,6 @@ from foundry_mcp.tools.unified.router import (
 
 logger = logging.getLogger(__name__)
 _metrics = get_metrics()
-_flag_service = get_flag_service()
-try:
-    _flag_service.register(
-        FeatureFlag(
-            name="provider_tools",
-            description="LLM provider management and execution tools",
-            state=FlagState.BETA,
-            default_enabled=True,
-        )
-    )
-except ValueError:
-    # Flag already registered
-    pass
 
 _ACTION_SUMMARY = {
     "list": "List registered providers with optional unavailable entries",
@@ -92,22 +78,6 @@ def _validation_error(
     )
 
 
-def _feature_flag_blocked(request_id: str) -> Optional[dict]:
-    if _flag_service.is_enabled("provider_tools"):
-        return None
-
-    return asdict(
-        error_response(
-            "Provider tools are disabled by feature flag",
-            error_code=ErrorCode.FEATURE_DISABLED,
-            error_type=ErrorType.FEATURE_FLAG,
-            data={"feature": "provider_tools"},
-            remediation="Enable the 'provider_tools' feature flag to call provider actions.",
-            request_id=request_id,
-        )
-    )
-
-
 def _handle_list(
     *,
     config: ServerConfig,  # noqa: ARG001 - reserved for future hooks
@@ -115,9 +85,6 @@ def _handle_list(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
 
     include = include_unavailable if isinstance(include_unavailable, bool) else False
     if include_unavailable is not None and not isinstance(include_unavailable, bool):
@@ -182,9 +149,6 @@ def _handle_status(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
 
     if not isinstance(provider_id, str) or not provider_id.strip():
         return _validation_error(
@@ -288,10 +252,6 @@ def _handle_execute(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
-
     action = "execute"
 
     if not isinstance(provider_id, str) or not provider_id.strip():