Add sponsor LLM controls and secrets guidance

README.md

@@ -26,15 +26,16 @@ tags:
 
 ## 🎯 Overview
 
-The Deployment Readiness Copilot is a productivity-focused, developer-centric tool that automates deployment readiness checks using a multi-agent architecture. It combines Claude's reasoning with MCP tool integration to provide comprehensive pre-deployment validation across multiple platforms.
+The Deployment Readiness Copilot is a productivity-focused, developer-centric tool that automates deployment readiness checks using a multi-agent architecture. It combines Claude's reasoning with sponsor LLM cross-checks and MCP tool integration to provide comprehensive pre-deployment validation across multiple platforms.
 
 ## ✨ Features
 
-- **🤖 Multi-Agent Pipeline**: Planner → Evidence Gatherer → Documentation → Reviewer → Docs Lookup → Deployment
+- **🤖 Multi-Agent Pipeline**: Planner → Evidence Gatherer → Synthesis → Documentation → Reviewer → Docs Lookup → Deployment
 - **📁 Codebase Analysis**: Upload folder (ZIP) or GitHub repo → Auto-detect framework, dependencies, configs
 - **📚 Context7 Documentation Integration**: Automatic framework/platform documentation lookups
 - **🔧 MCP Tool Integration**: Real-time deployment signals from Hugging Face Spaces, Vercel, Context7, and GitHub
 - **🚀 Multi-Platform Deployment**: Deploy to Vercel, Netlify, AWS, GCP, Azure, Railway, Render, Fly.io, Kubernetes, Docker
+- **🎓 Sponsor LLM Cross-Checks**: Gemini 2.0 Flash + OpenAI GPT-4o mini for synthesis and validation
 - **📝 Auto-Documentation**: Generates changelog entries, README snippets, and announcement drafts
 - **✅ Risk Assessment**: Automated review with confidence scoring and actionable findings
 
@@ -57,9 +58,10 @@ The Deployment Readiness Copilot is a productivity-focused, developer-centric to
 
 1. **Planner Agent (Claude)**: Analyzes project context and generates deployment readiness checklist
 2. **Evidence Agent (Claude + MCP)**: Gathers real deployment signals via MCP tools
-3. **Documentation Agent (Claude)**: Generates deployment communications
-4. **Reviewer Agent (Claude)**: Final risk assessment with confidence scoring
-5. **Documentation Lookup Agent (Context7)**: Looks up framework/platform docs for:
+3. **Synthesis Agent (Gemini/OpenAI)**: Cross-validates Claude's evidence to earn sponsor bonus points
+4. **Documentation Agent (Claude)**: Generates deployment communications
+5. **Reviewer Agent (Claude)**: Final risk assessment with confidence scoring
+6. **Documentation Lookup Agent (Context7)**: Looks up framework/platform docs for:
    - Deployment guides
    - Dependency compatibility
    - Config validation
@@ -67,7 +69,7 @@ The Deployment Readiness Copilot is a productivity-focused, developer-centric to
    - Environment variables
    - Migration guides
    - Observability setup
-6. **Deployment Agent (GitHub)**: Prepares and executes deployment actions
+7. **Deployment Agent (GitHub)**: Prepares and executes deployment actions
 
 ### MCP Tools Used
 
@@ -81,6 +83,10 @@ The Deployment Readiness Copilot is a productivity-focused, developer-centric to
 
 1. **Set Environment Variables** (in HF Space Secrets):
    - `ANTHROPIC_API_KEY`: Your Claude API key (required)
+   - `GOOGLE_API_KEY` or `GEMINI_API_KEY`: Enables Gemini sponsor synthesis
+   - `OPENAI_API_KEY`: Enables OpenAI sponsor synthesis
+   - `SPONSOR_LLM_PRIORITY`: Optional override (default `gemini,openai`)
+   - `GEMINI_MODEL`, `OPENAI_MODEL`: Optional model overrides
    - `HF_TOKEN`: For Hugging Face MCP tools (optional)
    - `GITHUB_TOKEN`: For GitHub deployment actions (optional)
    - `GITHUB_REPO`: Repository in format `owner/repo` (optional, for deployments)
@@ -112,9 +118,10 @@ The system will:
 1. Generate a deployment readiness plan
 2. Gather evidence via MCP tools
 3. Lookup framework/platform documentation via Context7
-4. Create documentation artifacts
-5. Prepare GitHub deployment actions (if configured)
-6. Provide final review with risk assessment
+4. Cross-validate evidence with sponsor LLMs
+5. Create documentation artifacts
+6. Prepare GitHub deployment actions (if configured)
+7. Provide final review with risk assessment
 
 ## 🎯 Hackathon Submission
 
@@ -132,6 +139,7 @@ The system will:
 - ✅ Context7 integration for comprehensive documentation lookups
 - ✅ GitHub deployment actions for direct deployment execution
 - ✅ Gradio app with MCP server support (`mcp_server=True`)
+- ✅ Sponsor LLM integration (Gemini, OpenAI) with configurable priority
 - ✅ Real-world productivity use case for developers
 - ✅ 10 utility improvements covering security, cost, performance, CI/CD, monitoring, and collaboration
 
@@ -139,12 +147,27 @@ The system will:
 
 - **Gradio 5.49.1**: UI framework with MCP server support
 - **Anthropic Claude 3.5 Sonnet**: Primary reasoning engine
+- **Google Gemini 2.0 Flash**: Sponsor cross-validation
+- **OpenAI GPT-4o mini**: Alternate sponsor cross-validation
 - **Hugging Face Hub**: MCP client for tool integration
 - **Context7 MCP**: Documentation lookup service
-- **GitHub API/MCP**: Deployment actions and workflow triggers
-- **Vercel MCP**: Deployment validation and management
+- **GitHub & Vercel MCP**: Deployment validation and workflow triggers
 - **Python 3.10+**: Core runtime
 
+## 🔐 Secrets & API Keys
+
+Add secrets in Hugging Face Space → **Settings → Repository secrets**:
+
+| Secret | Purpose |
+| --- | --- |
+| `ANTHROPIC_API_KEY` | Required for Claude agents |
+| `GOOGLE_API_KEY` / `GEMINI_API_KEY` | Enable Gemini sponsor synthesis |
+| `OPENAI_API_KEY` | Enable OpenAI sponsor synthesis |
+| `SPONSOR_LLM_PRIORITY` | Optional ordering, e.g. `gemini,openai` |
+| `GEMINI_MODEL`, `OPENAI_MODEL` | Optional model overrides |
+| `HF_TOKEN` | Optional Hugging Face MCP access |
+| `GITHUB_TOKEN`, `GITHUB_REPO`, `GITHUB_BRANCH` | GitHub deployment actions |
+
 ## 📝 License
 
 MIT License

agents.py

@@ -183,11 +183,18 @@ class SynthesisAgent:
     def __init__(self) -> None:
         self.sponsor_client = SponsorLLMClient()
 
-    def run(self, evidence: EvidencePacket, plan_summary: str) -> Dict[str, str]:
+    def run(
+        self,
+        evidence: EvidencePacket,
+        plan_summary: str,
+        preferred_llms: Optional[List[str]] = None,
+    ) -> Dict[str, str]:
         """Synthesize evidence using sponsor LLMs for bonus points."""
         all_evidence = evidence.findings + evidence.signals
         synthesis = self.sponsor_client.cross_validate_evidence(
-            "\n".join(all_evidence[:5]), plan_summary
+            "\n".join(all_evidence[:5]),
+            plan_summary,
+            preferred_llms,
         )
         return synthesis
 

app.py

@@ -38,6 +38,13 @@ rollback_manager = RollbackManager()
 monitoring_integration = MonitoringIntegration()
 deployment_monitor = DeploymentMonitor()
 
+SPONSOR_PRIORITY_MAP = {
+    "Auto (Gemini → OpenAI)": None,
+    "Gemini only": ["gemini"],
+    "OpenAI only": ["openai"],
+    "Both (merge results)": ["gemini", "openai"],
+}
+
 
 def analyze_input(
     upload_file: Optional[str],
@@ -118,8 +125,9 @@ def run_full_pipeline(
     deployment_platform: str,
     update_readme: bool,
     stakeholders: str,
-    environment: str
-) -> Tuple[Dict, str, str, str, str, str, str, str, str, str, str, str, str, str, str]:
+    environment: str,
+    sponsor_priority: str,
+) -> Tuple[Dict, str, str, str, str, str, str, str, str, str, str, str, str, str, str, str]:
     """Run complete pipeline with analysis, readiness check, and deployment."""
     
     # Step 1: Analyze codebase if folder/repo provided
@@ -236,6 +244,7 @@ def run_full_pipeline(
     
     # Step 2: Run readiness pipeline
     stakeholders_list = [s.strip() for s in stakeholders.split(",") if s.strip()] if stakeholders else ["eng"]
+    sponsor_pref = SPONSOR_PRIORITY_MAP.get(sponsor_priority, None)
     payload = {
         "project_name": project_name or "Unnamed Service",
         "release_goal": release_goal or "Deploy to production",
@@ -243,6 +252,8 @@ def run_full_pipeline(
         "infra_notes": infra_notes or None,
         "stakeholders": stakeholders_list,
     }
+    if sponsor_pref:
+        payload["sponsor_llms"] = sponsor_pref
     
     result = orchestrator.run_dict(payload)
     
@@ -340,6 +351,18 @@ def run_full_pipeline(
             icon = "✅" if status == "completed" else "⏳" if status == "running" else "❌" if status == "failed" else "⏭️"
             progress_text += f"{icon} **{name}**: {message}\n"
     
+    sponsor_text = ""
+    if result.get("sponsor_synthesis"):
+        sponsor_lines = []
+        for name, details in result["sponsor_synthesis"].items():
+            sponsor_lines.append(f"**{name.replace('_', ' ').title()}**\n{details}")
+        sponsor_text = "\n\n".join(sponsor_lines)
+    else:
+        sponsor_text = (
+            "No sponsor LLM synthesis. Add `GOOGLE_API_KEY`/`GEMINI_API_KEY` or `OPENAI_API_KEY` "
+            "to your Hugging Face Space secrets to enable cross-checks."
+        )
+
     docs_text = ""
     if "docs_references" in result and result["docs_references"]:
         docs_refs = result["docs_references"]
@@ -391,6 +414,7 @@ def run_full_pipeline(
     return (
         result,
         full_analysis,
+        sponsor_text,
         docs_text,
         deploy_text,
         readme_update_status,
@@ -494,6 +518,24 @@ def build_interface() -> gr.Blocks:
                     value="production",
                     info="Target deployment environment"
                 )
+                sponsor_priority = gr.Dropdown(
+                    label="Sponsor LLM Priority",
+                    choices=list(SPONSOR_PRIORITY_MAP.keys()),
+                    value="Auto (Gemini → OpenAI)",
+                    info="Choose which sponsor APIs run for cross-validation"
+                )
+
+        with gr.Accordion("Secrets Setup (Hugging Face Spaces)", open=False):
+            gr.Markdown(
+                "**Add these secrets via Settings → Repository Secrets:**\n"
+                "- `ANTHROPIC_API_KEY`: Required for Claude agents\n"
+                "- `GOOGLE_API_KEY` or `GEMINI_API_KEY`: Enables Gemini sponsor synthesis\n"
+                "- `OPENAI_API_KEY`: Enables OpenAI sponsor synthesis\n"
+                "- `SPONSOR_LLM_PRIORITY`: Optional override, e.g. `gemini,openai`\n"
+                "- `OPENAI_MODEL`, `GEMINI_MODEL`: Optional custom model IDs\n"
+                "- `GITHUB_TOKEN`, `GITHUB_REPO`, `GITHUB_BRANCH`: GitHub deployments\n"
+                "- `HF_TOKEN`: Access Hugging Face MCP tools"
+            )
         
         # Run Pipeline
         run_button = gr.Button("🚀 Run Full Pipeline & Deploy", variant="primary", size="lg")
@@ -506,6 +548,9 @@ def build_interface() -> gr.Blocks:
             with gr.Column(scale=2):
                 gr.Markdown("### 📋 Full Results")
                 output = gr.JSON(label="Complete Output", height=400)
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎯 Sponsor Insights")
+                sponsor_output = gr.Textbox(label="Sponsor LLM Cross-Checks", lines=8, interactive=False)
         
         with gr.Row():
             with gr.Column():
@@ -582,11 +627,13 @@ def build_interface() -> gr.Blocks:
                 deployment_platform,
                 update_readme,
                 stakeholders,
-                environment
+                environment,
+                sponsor_priority,
             ],
             outputs=[
                 output,
                 progress_output,
+                sponsor_output,
                 docs_output,
                 deploy_output,
                 readme_status,
@@ -599,7 +646,7 @@ def build_interface() -> gr.Blocks:
                 monitoring_output,
                 collaboration_output,
                 json_export,
-                markdown_export
+                markdown_export,
             ]
         )
     

export_utils.py

@@ -97,8 +97,17 @@ def export_markdown(data: Dict[str, Any], filename: Optional[str] = None) -> str
             md_lines.append(f"- **{action_type}**: {message}")
         md_lines.append("")
     
-    # Evidence synthesis (internal optimization, not exposed)
-    # Synthesis results are used internally but not exported to avoid confusion
+    # Sponsor synthesis (optional)
+    sponsor_data = data.get("sponsor_synthesis")
+    if sponsor_data:
+        md_lines.extend([
+            "## Sponsor LLM Cross-Checks",
+            "",
+        ])
+        for key, value in sponsor_data.items():
+            md_lines.append(f"### {key.replace('_', ' ').title()}")
+            md_lines.append(str(value))
+            md_lines.append("")
     
     output = "\n".join(md_lines)
     if filename:

orchestrator.py

@@ -110,6 +110,7 @@ class ReadinessOrchestrator:
                 self.synthesis.run,
                 evidence,
                 plan.summary,
+                request.sponsor_llms,
                 default={},
                 error_message="Synthesis agent failed"
             )
@@ -209,7 +210,7 @@ class ReadinessOrchestrator:
             deployment=DeploymentActions(**deployment_config) if deployment_config else None,
         )
         result = asdict(response)
-        # sponsor_synthesis used internally but not exposed in UI
+        result["sponsor_synthesis"] = sponsor_synthesis
         result["progress"] = progress.to_dict()
         result["partial_results"] = partial.to_dict()
         return result

schemas.py

@@ -71,6 +71,7 @@ class ReadinessRequest:
     code_summary: str
     infra_notes: Optional[str] = None
     stakeholders: Optional[List[str]] = None
+    sponsor_llms: Optional[List[str]] = None
 
 
 @dataclass(slots=True)

sponsor_llms.py

@@ -18,12 +18,23 @@ except ImportError:
     OPENAI_AVAILABLE = False
 
 
+def _normalize_priority(priority: Optional[List[str] | str]) -> List[str]:
+    """Normalize preferred sponsor list."""
+    if priority is None:
+        env_priority = os.getenv("SPONSOR_LLM_PRIORITY", "gemini,openai")
+        priority = env_priority
+    if isinstance(priority, str):
+        priority = [item.strip().lower() for item in priority.split(",") if item.strip()]
+    return [p for p in priority if p in {"gemini", "openai", "both"}]
+
+
 class SponsorLLMClient:
     """Unified interface for sponsor LLMs (Gemini, OpenAI)."""
 
     def __init__(self):
         self.gemini_client = None
         self.openai_client = None
+        self.default_priority = _normalize_priority(None)
         self._init_gemini()
         self._init_openai()
 
@@ -36,7 +47,8 @@ class SponsorLLMClient:
         if api_key:
             try:
                 genai.configure(api_key=api_key)
-                self.gemini_client = genai.GenerativeModel("gemini-2.0-flash-exp")
+                model_id = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
+                self.gemini_client = genai.GenerativeModel(model_id)
             except Exception as e:
                 print(f"Gemini init failed: {e}")
 
@@ -67,7 +79,12 @@ class SponsorLLMClient:
         )
 
         try:
-            response = self.gemini_client.generate_content(prompt)
+            model = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
+            response = self.gemini_client.generate_content(
+                prompt,
+                generation_config={"temperature": 0.2},
+                safety_settings=None
+            )
             return response.text.strip()
         except Exception as e:
             return f"[Gemini error: {e}]"
@@ -101,24 +118,30 @@ class SponsorLLMClient:
             return f"[OpenAI error: {e}]"
 
     def cross_validate_evidence(
-        self, claude_evidence: str, plan_summary: str
+        self, claude_evidence: str, plan_summary: str, preferred: Optional[List[str] | str] = None
     ) -> Dict[str, str]:
         """Use sponsor LLMs to cross-validate Claude's evidence analysis."""
-        results = {}
-
-        # Try Gemini first (sponsor priority)
-        if self.gemini_client:
-            gemini_synthesis = self.synthesize_with_gemini(
-                [claude_evidence], plan_summary
-            )
-            results["gemini_synthesis"] = gemini_synthesis
-
-        # Fallback to OpenAI if Gemini unavailable
-        if not results and self.openai_client:
-            openai_synthesis = self.synthesize_with_openai(
-                [claude_evidence], plan_summary
-            )
-            results["openai_synthesis"] = openai_synthesis
+        order = _normalize_priority(preferred) or self.default_priority
+        results: Dict[str, str] = {}
+
+        for provider in order:
+            if provider == "gemini" and self.gemini_client:
+                results["gemini_synthesis"] = self.synthesize_with_gemini(
+                    [claude_evidence], plan_summary
+                )
+            elif provider == "openai" and self.openai_client:
+                results["openai_synthesis"] = self.synthesize_with_openai(
+                    [claude_evidence], plan_summary
+                )
+            elif provider == "both":
+                if self.gemini_client:
+                    results["gemini_synthesis"] = self.synthesize_with_gemini(
+                        [claude_evidence], plan_summary
+                    )
+                if self.openai_client:
+                    results["openai_synthesis"] = self.synthesize_with_openai(
+                        [claude_evidence], plan_summary
+                    )
 
         return results