feat: wire TestGenerator into mine command

- Added OpenRouterClient and TestGenerator imports to mine.py
- Pass test_generator to SwePipelineConfig
- Fixed await on _create_sandbox in pipeline.py
- Fixed DockerSandbox to enter DockerClient context
- Fixed test mocking for async _create_sandbox

Author: echobt

src/swe_forge/cli/mine.py

@@ -25,6 +25,7 @@
 )
 
 from swe_forge.export.jsonl import export_jsonl
+from swe_forge.llm.openrouter import OpenRouterClient
 from swe_forge.swe.github_api import GitHubClient
 from swe_forge.swe.gharchive import GhArchiveClient
 from swe_forge.swe.models import SweTask
@@ -34,6 +35,7 @@
     SwePipelineConfig,
     SwePipelineEventType,
 )
+from swe_forge.swe.test_generator import TestGenerator
 from swe_forge.swe.concurrency import set_docker_containers_limit
 
 logger = logging.getLogger(__name__)
@@ -278,7 +280,7 @@ def mine(
 
     # Run the pipeline
     try:
-        result = asyncio.run(_run_pipeline(github_token, config, repo, verbose))
+        result = asyncio.run(_run_pipeline(github_token, config, repo, verbose, model))
 
         if result.tasks:
             # Export results
@@ -417,6 +419,7 @@ async def _run_pipeline(
     config: SwePipelineConfig,
     repo_filter: Optional[str],
     verbose: bool,
+    model: str = "moonshotai/kimi-k2.5",
 ):
     """Run the SWE pipeline with progress tracking."""
     from dataclasses import dataclass, field
@@ -426,6 +429,15 @@ class PipelineResult:
         tasks: list = field(default_factory=list)
         benchmark_metrics: object = None
 
+    # Create LLM client and TestGenerator for test generation
+    openrouter_key = os.environ.get("OPENROUTER_API_KEY", "")
+    llm_client = None
+    test_generator = None
+    if openrouter_key:
+        llm_client = OpenRouterClient(api_key=openrouter_key, default_model=model)
+        test_generator = TestGenerator(llm=llm_client, model=model)
+        config.test_generator = test_generator
+
     async with GitHubClient(token=token) as gh_client:
         gh_archive_client = GhArchiveClient(token=token) if not repo_filter else None
 
@@ -577,7 +589,6 @@ async def _run_complete_mining(
 ):
     """Run the complete mining pipeline."""
     from swe_forge.pipeline import CompleteMiningPipeline
-    from swe_forge.llm.openrouter import OpenRouterClient
 
     llm_client = None
     if openrouter_key:

src/swe_forge/execution/sandbox.py

@@ -119,6 +119,7 @@ def __init__(
         self._state = SandboxState()
         self._manager: ContainerManager | None = None
         self._semaphore_acquired: bool = False
+        self._client_own_connection: bool = False
 
     @classmethod
     def from_spec(
@@ -159,6 +160,13 @@ async def __aenter__(self) -> "DockerSandbox":
         await sem.acquire()
         self._semaphore_acquired = True
 
+        # Enter DockerClient's async context if not already entered
+        if self._client._docker is None:
+            await self._client.__aenter__()
+            self._client_own_connection = True
+        else:
+            self._client_own_connection = False
+
         spec = ContainerSpec(
             name=self._container_name,
             image=self._config.image,
@@ -179,6 +187,8 @@ async def __aenter__(self) -> "DockerSandbox":
             self._manager = None
             sem.release()
             self._semaphore_acquired = False
+            if self._client_own_connection:
+                await self._client.__aexit__(None, None, None)
             raise
 
         logger.info(
@@ -202,6 +212,9 @@ async def __aexit__(
             self._manager = None
             self._state.container_id = None
 
+        if self._client_own_connection:
+            await self._client.__aexit__(exc_type, exc_val, exc_tb)
+
         if self._semaphore_acquired:
             get_docker_semaphore().release()
             self._semaphore_acquired = False

src/swe_forge/swe/pipeline.py

@@ -458,7 +458,7 @@ async def _run_test_generation(
         sandbox: DockerSandbox | None = None
 
         try:
-            sandbox = self._create_sandbox(repo_url, enriched.base_commit)
+            sandbox = await self._create_sandbox(repo_url, enriched.base_commit)
 
             async with sandbox:
                 await sandbox.setup_workspace(repo_url, enriched.base_commit)

tests/test_swe/test_pipeline_integration.py

@@ -130,14 +130,14 @@ def sample_enriched_pr() -> EnrichedPullRequest:
 def _bind_mock_sandbox(pipeline: SwePipeline, mock_sandbox: MockSandbox):
     """Bind mock sandbox to pipeline's _create_sandbox.
 
-    The source code calls _create_sandbox without await, so we bind a
-    sync function that returns the mock directly (not a coroutine).
+    The source code calls _create_sandbox with await, so we bind an
+    async function that returns the mock.
     """
 
-    def create_sandbox_sync(self, repo_url: str, base_commit: str):
+    async def create_sandbox_async(self, repo_url: str, base_commit: str):
         return mock_sandbox
 
-    pipeline._create_sandbox = create_sandbox_sync.__get__(pipeline, type(pipeline))
+    pipeline._create_sandbox = create_sandbox_async.__get__(pipeline, type(pipeline))
 
 
 class TestGeneratorCalledWhenConfigured: