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

foundry_mcp/core/research/workflows/consensus.py

@@ -6,9 +6,12 @@ synthesis strategies for combining responses.
 
 import asyncio
 import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any, Optional
 
 from foundry_mcp.config import ResearchConfig
+from foundry_mcp.core.llm_config import ProviderSpec
 from foundry_mcp.core.providers import ProviderHooks, ProviderRequest, ProviderStatus
 from foundry_mcp.core.providers.registry import available_providers, resolve_provider
 from foundry_mcp.core.research.memory import ResearchMemory
@@ -75,18 +78,36 @@ class ConsensusWorkflow(ResearchWorkflowBase):
         Returns:
             WorkflowResult with synthesized or combined response
         """
-        # Resolve providers
-        provider_ids = providers or self.config.consensus_providers
+        # Resolve providers - parse specs and check availability
+        provider_specs = providers or self.config.consensus_providers
         available = available_providers()
-        valid_providers = [p for p in provider_ids if p in available]
 
-        if not valid_providers:
+        # Parse each provider spec and filter by availability
+        valid_specs: list[ProviderSpec] = []
+        for spec_str in provider_specs:
+            try:
+                spec = ProviderSpec.parse_flexible(spec_str)
+                if spec.provider in available:
+                    valid_specs.append(spec)
+                else:
+                    logger.warning(
+                        "Provider %s (from spec '%s') not available",
+                        spec.provider,
+                        spec_str,
+                    )
+            except ValueError as exc:
+                logger.warning("Invalid provider spec '%s': %s", spec_str, exc)
+
+        if not valid_specs:
             return WorkflowResult(
                 success=False,
                 content="",
-                error=f"No valid providers available. Requested: {provider_ids}, Available: {available}",
+                error=f"No valid providers available. Requested: {provider_specs}, Available: {available}",
             )
 
+        # Use full spec strings for tracking, but we'll parse again when resolving
+        valid_providers = [spec.raw or f"{spec.provider}:{spec.model}" if spec.model else spec.provider for spec in valid_specs]
+
         # Create consensus config and state
         consensus_config = ConsensusConfig(
             providers=valid_providers,
@@ -104,16 +125,15 @@ class ConsensusWorkflow(ResearchWorkflowBase):
             system_prompt=system_prompt,
         )
 
-        # Execute parallel requests
+        # Execute parallel requests using ThreadPoolExecutor
+        # This avoids asyncio.run() conflicts with MCP server's event loop
         try:
-            responses = asyncio.run(
-                self._execute_parallel(
-                    prompt=prompt,
-                    providers=valid_providers,
-                    system_prompt=system_prompt,
-                    timeout=timeout_per_provider,
-                    max_concurrent=max_concurrent,
-                )
+            responses = self._execute_parallel_sync(
+                prompt=prompt,
+                providers=valid_providers,
+                system_prompt=system_prompt,
+                timeout=timeout_per_provider,
+                max_concurrent=max_concurrent,
             )
         except Exception as exc:
             logger.error("Parallel execution failed: %s", exc)
@@ -167,6 +187,124 @@ class ConsensusWorkflow(ResearchWorkflowBase):
 
         return result
 
+    def _execute_parallel_sync(
+        self,
+        prompt: str,
+        providers: list[str],
+        system_prompt: Optional[str],
+        timeout: float,
+        max_concurrent: int,
+    ) -> list[ModelResponse]:
+        """Execute requests to multiple providers in parallel using ThreadPoolExecutor.
+
+        This approach avoids asyncio.run() conflicts when called from within
+        an MCP server's event loop.
+
+        Args:
+            prompt: User prompt
+            providers: Provider IDs to query
+            system_prompt: Optional system prompt
+            timeout: Timeout per provider
+            max_concurrent: Max concurrent requests
+
+        Returns:
+            List of ModelResponse objects
+        """
+        responses: list[ModelResponse] = []
+
+        with ThreadPoolExecutor(max_workers=max_concurrent) as executor:
+            # Submit all provider queries
+            future_to_provider = {
+                executor.submit(
+                    self._query_provider_sync,
+                    provider_id,
+                    prompt,
+                    system_prompt,
+                    timeout,
+                ): provider_id
+                for provider_id in providers
+            }
+
+            # Collect results as they complete
+            for future in as_completed(future_to_provider, timeout=timeout * len(providers)):
+                provider_id = future_to_provider[future]
+                try:
+                    response = future.result()
+                    responses.append(response)
+                except Exception as exc:
+                    responses.append(
+                        ModelResponse(
+                            provider_id=provider_id,
+                            content="",
+                            success=False,
+                            error_message=str(exc),
+                        )
+                    )
+
+        return responses
+
+    def _query_provider_sync(
+        self,
+        provider_id: str,
+        prompt: str,
+        system_prompt: Optional[str],
+        timeout: float,
+    ) -> ModelResponse:
+        """Query a single provider synchronously.
+
+        Args:
+            provider_id: Provider ID or full spec (e.g., "[cli]codex:gpt-5.2")
+            prompt: User prompt
+            system_prompt: Optional system prompt
+            timeout: Request timeout
+
+        Returns:
+            ModelResponse with result or error
+        """
+        start_time = time.perf_counter()
+
+        try:
+            # Parse provider spec to extract base ID and model
+            spec = ProviderSpec.parse_flexible(provider_id)
+            provider = resolve_provider(spec.provider, hooks=ProviderHooks(), model=spec.model)
+            request = ProviderRequest(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                timeout=timeout,
+            )
+
+            result = provider.generate(request)
+            duration_ms = (time.perf_counter() - start_time) * 1000
+
+            if result.status != ProviderStatus.SUCCESS:
+                return ModelResponse(
+                    provider_id=provider_id,
+                    model_used=result.model_used,
+                    content=result.content or "",
+                    success=False,
+                    error_message=f"Provider returned status: {result.status.value}",
+                    duration_ms=duration_ms,
+                )
+
+            return ModelResponse(
+                provider_id=provider_id,
+                model_used=result.model_used,
+                content=result.content,
+                success=True,
+                tokens_used=result.tokens.total_tokens if result.tokens else None,
+                duration_ms=duration_ms,
+            )
+
+        except Exception as exc:
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            return ModelResponse(
+                provider_id=provider_id,
+                content="",
+                success=False,
+                error_message=str(exc),
+                duration_ms=duration_ms,
+            )
+
     async def _execute_parallel(
         self,
         prompt: str,
@@ -175,7 +313,10 @@ class ConsensusWorkflow(ResearchWorkflowBase):
         timeout: float,
         max_concurrent: int,
     ) -> list[ModelResponse]:
-        """Execute requests to multiple providers in parallel.
+        """Execute requests to multiple providers in parallel (async version).
+
+        Note: This async method is kept for potential future use but the sync
+        version (_execute_parallel_sync) is preferred to avoid event loop conflicts.
 
         Args:
             prompt: User prompt
@@ -228,7 +369,7 @@ class ConsensusWorkflow(ResearchWorkflowBase):
         """Query a single provider asynchronously.
 
         Args:
-            provider_id: Provider to query
+            provider_id: Provider ID or full spec (e.g., "[cli]codex:gpt-5.2")
             prompt: User prompt
             system_prompt: Optional system prompt
             timeout: Request timeout
@@ -241,7 +382,9 @@ class ConsensusWorkflow(ResearchWorkflowBase):
         start_time = time.perf_counter()
 
         try:
-            provider = resolve_provider(provider_id, hooks=ProviderHooks())
+            # Parse provider spec to extract base ID and model
+            spec = ProviderSpec.parse_flexible(provider_id)
+            provider = resolve_provider(spec.provider, hooks=ProviderHooks(), model=spec.model)
             request = ProviderRequest(
                 prompt=prompt,
                 system_prompt=system_prompt,