wafer-cli 0.2.31__py3-none-any.whl → 0.2.33__py3-none-any.whl

wafer/corpus.py

@@ -109,34 +109,14 @@ CORPORA: dict[CorpusName, CorpusConfig] = {
     ),
     "hip": CorpusConfig(
         name="hip",
-        description="HIP programming guide, API reference, and examples",
-        source_type="github_multi_repo",
-        repos=[
-            # HIP - main documentation and API
-            RepoSource(
-                repo="ROCm/HIP",
-                paths=["docs"],
-            ),
-            # HIP examples - code samples
-            RepoSource(
-                repo="ROCm/HIP-Examples",
-                paths=["HIP-Examples-Applications", "mini-nbody"],
-            ),
-            # clr - HIP/OpenCL runtime (low-level)
-            RepoSource(
-                repo="ROCm/clr",
-                paths=["hipamd/include", "rocclr/device/gpu"],
-            ),
-            # ROCm docs - official documentation
-            RepoSource(
-                repo="ROCm/ROCm",
-                paths=["docs"],
-            ),
-        ],
+        description="HIP programming guide and API reference",
+        source_type="github_repo",
+        repo="ROCm/HIP",
+        repo_paths=["docs"],
     ),
     "amd": CorpusConfig(
         name="amd",
-        description="AMD GPU kernel development (rocWMMA, CK, AITER, rocBLAS, HipKittens, vLLM, FlashAttention)",
+        description="AMD GPU kernel development (rocWMMA, CK, AITER, rocBLAS, HipKittens, vLLM)",
         source_type="github_multi_repo",
         repos=[
             # rocWMMA - wave matrix multiply-accumulate (WMMA) intrinsics
@@ -180,17 +160,11 @@ CORPORA: dict[CorpusName, CorpusConfig] = {
                 paths=["docs"],
                 branch="develop_deprecated",
             ),
-            # HipKittens - high-performance AMD kernels (main branch: MI350X/CDNA4+)
+            # HipKittens - high-performance AMD kernels
             RepoSource(
                 repo="HazyResearch/HipKittens",
                 paths=["docs", "kernels", "include"],
             ),
-            # HipKittens cdna3 branch - MI300X/MI325X (gfx942)
-            RepoSource(
-                repo="HazyResearch/HipKittens",
-                paths=["kernels", "include", "tests"],
-                branch="cdna3",
-            ),
             # vLLM AMD kernels
             RepoSource(
                 repo="vllm-project/vllm",
@@ -206,46 +180,6 @@ CORPORA: dict[CorpusName, CorpusConfig] = {
                 repo="huggingface/hf-rocm-kernels",
                 paths=["csrc", "hf_rocm_kernels", "docs"],
             ),
-            # ROCm/flash-attention - FlashAttention for AMD GPUs
-            RepoSource(
-                repo="ROCm/flash-attention",
-                paths=["csrc", "docs"],
-            ),
-            # ROCm/triton - Triton compiler for AMD GPUs
-            RepoSource(
-                repo="ROCm/triton",
-                paths=["python/tutorials", "third_party/amd"],
-            ),
-            # ROCm/rccl - ROCm Communication Collectives Library (multi-GPU)
-            RepoSource(
-                repo="ROCm/rccl",
-                paths=["docs"],
-            ),
-            # ROCm/rocprofiler-sdk - AMD GPU profiling SDK
-            RepoSource(
-                repo="ROCm/rocprofiler-sdk",
-                paths=["docs", "samples"],
-            ),
-            # ROCm/omniperf - AMD GPU profiling tool
-            RepoSource(
-                repo="ROCm/omniperf",
-                paths=["docs", "src/omniperf_analyze"],
-            ),
-            # ROCm/omnitrace - Application tracing for AMD
-            RepoSource(
-                repo="ROCm/omnitrace",
-                paths=["docs"],
-            ),
-            # AMD GPUOpen Performance Guides
-            RepoSource(
-                repo="GPUOpen-Tools/gpu_performance_api",
-                paths=["docs"],
-            ),
-            # AMD LLVM - AMD GPU compiler backend
-            RepoSource(
-                repo="ROCm/llvm-project",
-                paths=["amd/device-libs/README.md", "llvm/docs/AMDGPUUsage.rst"],
-            ),
         ],
     ),
 }

wafer/evaluate.py

@@ -78,10 +78,9 @@ def _build_docker_run_command(
         for cap in cap_add:
             parts.extend(["--cap-add", cap])
 
-    # GPU access - use --runtime=nvidia alongside --gpus for compatibility
-    # with newer NVIDIA drivers (580+) where --gpus alone may not initialize CUDA
+    # GPU access - use single quotes for the device spec to avoid shell escaping issues
     if gpus:
-        parts.extend(["--runtime=nvidia", "--gpus", f"'{gpus}'"])
+        parts.extend(["--gpus", f"'{gpus}'"])
 
     # Volume mounts
     if volumes:
@@ -380,6 +379,18 @@ def _build_docker_pip_install_cmd(target: BaremetalTarget | VMTarget) -> str:
     return " && ".join(commands)
 
 
+def _get_wafer_root() -> Path:
+    """Get wafer monorepo root directory.
+
+    Walks up from this file to find the wafer repo root (contains apps/, packages/).
+    """
+    current = Path(__file__).resolve()
+    for parent in [current] + list(current.parents):
+        if (parent / "apps").is_dir() and (parent / "packages").is_dir():
+            return parent
+    raise RuntimeError(f"Could not find wafer root from {__file__}")
+
+
 async def run_evaluate_docker(
     args: EvaluateArgs,
     target: BaremetalTarget | VMTarget,
@@ -2022,13 +2033,54 @@ async def run_evaluate_runpod(
                         error_message=f"Failed to setup Python environment: {e}",
                     )
 
-                # Install wafer-core in remote venv
-                print("Installing wafer-core...")
-                install_result = await client.exec(
-                    f'export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH" && '
-                    f"uv pip install --python {python_exe} wafer-core"
-                )
-                if install_result.exit_code != 0:
+                # Upload wafer-core to remote
+                try:
+                    wafer_root = _get_wafer_root()
+                    wafer_core_path = wafer_root / "packages" / "wafer-core"
+                    print(f"Uploading wafer-core from {wafer_core_path}...")
+
+                    wafer_core_remote = f"{REMOTE_WORKSPACE}/wafer-core"
+                    await client.exec(f"mkdir -p {wafer_core_remote}")
+                    wafer_core_workspace = await client.expand_path(wafer_core_remote)
+
+                    upload_result = await client.upload_files(
+                        str(wafer_core_path), wafer_core_workspace, recursive=True
+                    )
+
+                    # Wide event logging for upload result
+                    upload_event = {
+                        "event": "wafer_core_upload",
+                        "target": target.name,
+                        "target_type": "runpod",
+                        "ssh_host": f"{client.user}@{client.host}:{client.port}",
+                        "local_path": str(wafer_core_path),
+                        "remote_path": wafer_core_workspace,
+                        "success": upload_result.success,
+                        "files_copied": upload_result.files_copied,
+                        "duration_seconds": upload_result.duration_seconds,
+                        "error_message": upload_result.error_message,
+                    }
+                    if upload_result.debug_info:
+                        upload_event["debug_info"] = upload_result.debug_info
+                    logger.info(json.dumps(upload_event))
+
+                    # Fail fast if upload failed
+                    if not upload_result.success:
+                        print(f"ERROR: Upload failed: {upload_result.error_message}")
+                        if upload_result.debug_info:
+                            print(f"Debug info: {json.dumps(upload_result.debug_info, indent=2)}")
+                        return EvaluateResult(
+                            success=False,
+                            all_correct=False,
+                            correctness_score=0.0,
+                            geomean_speedup=0.0,
+                            passed_tests=0,
+                            total_tests=0,
+                            error_message=f"Failed to upload wafer-core: {upload_result.error_message}",
+                        )
+
+                    print(f"Uploaded {upload_result.files_copied} files")
+                except Exception as e:
                     return EvaluateResult(
                         success=False,
                         all_correct=False,
@@ -2036,7 +2088,7 @@ async def run_evaluate_runpod(
                         geomean_speedup=0.0,
                         passed_tests=0,
                         total_tests=0,
-                        error_message=f"Failed to install wafer-core: {install_result.stderr}",
+                        error_message=f"Failed to upload wafer-core: {e}",
                     )
 
                 # Select GPU (RunPod pods typically have GPU 0)
@@ -2177,18 +2229,11 @@ async def run_evaluate_runpod(
                         error_message=f"Evaluation timed out after {target.eval_timeout}s",
                     )
 
-                # Show output to user
+                # Parse output
                 stdout = result.stdout
                 stderr = result.stderr
-                if stdout:
-                    print(stdout)
 
                 if result.exit_code != 0:
-                    error_parts = [f"Evaluation failed (exit code {result.exit_code}):"]
-                    if stdout:
-                        error_parts.append(f"stdout: {stdout}")
-                    if stderr:
-                        error_parts.append(f"stderr: {stderr}")
                     return EvaluateResult(
                         success=False,
                         all_correct=False,
@@ -2196,27 +2241,20 @@ async def run_evaluate_runpod(
                         geomean_speedup=0.0,
                         passed_tests=0,
                         total_tests=0,
-                        error_message="\n".join(error_parts),
+                        error_message=f"Evaluation failed:\nstdout: {stdout}\nstderr: {stderr}",
                     )
 
-                # Read results from results.json file written by evaluate module
-                results_path = f"{run_path}/results.json"
-                cat_result = await client.exec(f"cat {results_path}")
-
-                if cat_result.exit_code != 0:
-                    return EvaluateResult(
-                        success=False,
-                        all_correct=False,
-                        correctness_score=0.0,
-                        geomean_speedup=0.0,
-                        passed_tests=0,
-                        total_tests=0,
-                        error_message=f"Failed to read results: {cat_result.stderr}",
-                    )
-
-                try:
-                    results_data = json.loads(cat_result.stdout)
-                except json.JSONDecodeError as e:
+                # Find JSON result in output
+                result_json = None
+                for line in reversed(stdout.strip().split("\n")):
+                    if line.startswith("{"):
+                        try:
+                            result_json = json.loads(line)
+                            break
+                        except json.JSONDecodeError:
+                            continue
+
+                if result_json is None:
                     return EvaluateResult(
                         success=False,
                         all_correct=False,
@@ -2224,12 +2262,10 @@ async def run_evaluate_runpod(
                         geomean_speedup=0.0,
                         passed_tests=0,
                         total_tests=0,
-                        error_message=f"Invalid JSON in results: {e}",
+                        error_message=f"No JSON result in output:\n{stdout}",
                     )
 
-                # Extract backend results (same format as DigitalOcean/SSH path)
-                backends = results_data.get("backends", [])
-                if not backends:
+                if "error" in result_json:
                     return EvaluateResult(
                         success=False,
                         all_correct=False,
@@ -2237,20 +2273,18 @@ async def run_evaluate_runpod(
                         geomean_speedup=0.0,
                         passed_tests=0,
                         total_tests=0,
-                        error_message="No backend results found",
+                        error_message=result_json["error"],
                     )
 
-                backend = backends[0]
-                correctness_tests = backend.get("correctness_tests", [])
-                passed = sum(1 for t in correctness_tests if t.get("is_correct", False))
-                total = len(correctness_tests)
+                passed = result_json.get("passed", 0)
+                total = result_json.get("total", 0)
                 correctness = passed / total if total > 0 else 0.0
 
                 return EvaluateResult(
                     success=True,
-                    all_correct=backend.get("all_correct", False),
+                    all_correct=result_json.get("all_correct", False),
                     correctness_score=correctness,
-                    geomean_speedup=backend.get("geomean_speedup", 0.0),
+                    geomean_speedup=result_json.get("speedup", 0.0),
                     passed_tests=passed,
                     total_tests=total,
                 )
@@ -2351,13 +2385,61 @@ async def run_evaluate_digitalocean(
                             error_message=f"Failed to setup Python environment: {e}",
                         )
 
-                    # Install wafer-core in remote venv
-                    print("Installing wafer-core...")
-                    install_result = await client.exec(
-                        f'export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH" && '
-                        f"uv pip install --python {python_exe} wafer-core"
-                    )
-                    if install_result.exit_code != 0:
+                    # Upload wafer-core to remote
+                    try:
+                        wafer_root = _get_wafer_root()
+                        wafer_core_path = wafer_root / "packages" / "wafer-core"
+                        print(f"Uploading wafer-core from {wafer_core_path}...")
+
+                        wafer_core_remote = f"{REMOTE_WORKSPACE}/wafer-core"
+                        await client.exec(f"mkdir -p {wafer_core_remote}")
+                        wafer_core_workspace = await client.expand_path(wafer_core_remote)
+
+                        # Use SFTP instead of rsync to avoid SSH subprocess timeout issues
+                        # (DigitalOcean may rate-limit new SSH connections)
+                        upload_result = await client.upload_files(
+                            str(wafer_core_path),
+                            wafer_core_workspace,
+                            recursive=True,
+                            use_sftp=True,
+                        )
+
+                        # Wide event logging for upload result
+                        upload_event = {
+                            "event": "wafer_core_upload",
+                            "target": target.name,
+                            "target_type": "digitalocean",
+                            "ssh_host": f"{client.user}@{client.host}:{client.port}",
+                            "local_path": str(wafer_core_path),
+                            "remote_path": wafer_core_workspace,
+                            "success": upload_result.success,
+                            "files_copied": upload_result.files_copied,
+                            "duration_seconds": upload_result.duration_seconds,
+                            "error_message": upload_result.error_message,
+                        }
+                        if upload_result.debug_info:
+                            upload_event["debug_info"] = upload_result.debug_info
+                        logger.info(json.dumps(upload_event))
+
+                        # Fail fast if upload failed
+                        if not upload_result.success:
+                            print(f"ERROR: Upload failed: {upload_result.error_message}")
+                            if upload_result.debug_info:
+                                print(
+                                    f"Debug info: {json.dumps(upload_result.debug_info, indent=2)}"
+                                )
+                            return EvaluateResult(
+                                success=False,
+                                all_correct=False,
+                                correctness_score=0.0,
+                                geomean_speedup=0.0,
+                                passed_tests=0,
+                                total_tests=0,
+                                error_message=f"Failed to upload wafer-core: {upload_result.error_message}",
+                            )
+
+                        print(f"Uploaded {upload_result.files_copied} files")
+                    except Exception as e:
                         return EvaluateResult(
                             success=False,
                             all_correct=False,
@@ -2365,7 +2447,7 @@ async def run_evaluate_digitalocean(
                             geomean_speedup=0.0,
                             passed_tests=0,
                             total_tests=0,
-                            error_message=f"Failed to install wafer-core: {install_result.stderr}",
+                            error_message=f"Failed to upload wafer-core: {e}",
                         )
 
                     # Select GPU (DigitalOcean droplets typically have GPU 0)
@@ -3160,35 +3242,15 @@ def main():
             inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
 
             if run_defense and defense_module is not None:
-                # Use extended defense suite (Makora taxonomy + CUDA-L2)
+                # Use full defense suite
                 print("[KernelBench] Running defense checks on implementation...")
-                run_extended = defense_module.run_all_defenses_extended
+                run_all_defenses = defense_module.run_all_defenses
                 time_with_defenses = defense_module.time_execution_with_defenses
 
-                # Read source code for LLM adversarial evaluator
-                _problem_code = None
-                _kernel_code = None
-                try:
-                    _problem_code = Path(args.reference).read_text()
-                    _kernel_code = Path(args.impl).read_text()
-                except Exception:
-                    pass
-
-                # Input generator for caching/multi-input checks
-                def _input_generator():
-                    _ins = get_inputs()
-                    return tuple(x.cuda() if isinstance(x, torch.Tensor) else x for x in _ins)
-
-                # Run all defense checks (original + extended)
-                all_passed, defense_results, _ = run_extended(
+                # Run defense checks on implementation
+                all_passed, defense_results, _ = run_all_defenses(
                     lambda *x: new_model(*x),
                     *inputs,
-                    reference_fn=lambda *x: ref_model(*x),
-                    input_generator=_input_generator,
-                    test_shapes=[(128, 128), (256, 256), (512, 512)],
-                    check_precision_ulp=True,
-                    problem_code=_problem_code,
-                    kernel_code=_kernel_code,
                 )
                 results["defense_results"] = {
                     name: {"passed": passed, "message": msg}

wafer/global_config.py

@@ -234,20 +234,7 @@ def get_supabase_anon_key() -> str:
 
     The anon key is public and used for client-side auth operations
     like token refresh.
-
-    If SUPABASE_URL is set via env var, infer the matching anon key
-    from the built-in environments. Otherwise, use the config file's environment.
     """
-    supabase_url = get_supabase_url()
-    
-    # If SUPABASE_URL was set via env var, find matching environment
-    if os.environ.get("SUPABASE_URL"):
-        # Check built-in environments to find matching Supabase URL
-        for env_name, env in BUILTIN_ENVIRONMENTS.items():
-            if env.supabase_url == supabase_url:
-                return env.supabase_anon_key
-    
-    # Otherwise, use config file's environment
     return load_global_config().get_api_environment().supabase_anon_key
 
 

wafer/kernel_scope.py

@@ -95,7 +95,7 @@ def analyze_command(
             if not api_url or not auth_headers:
                 raise RuntimeError(
                     "API authentication required for .co file analysis. "
-                    "Run 'wafer auth login' first."
+                    "Run 'wafer login' first."
                 )
             result = analyze_code_object(target_path, api_url, auth_headers)
         # ISA files - use kernel_index parameter

wafer/ncu_analyze.py

@@ -520,7 +520,7 @@ def _analyze_remote_api(
 
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer auth login") from e
+            raise RuntimeError("Not authenticated. Run: wafer login") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e

wafer/nsys_analyze.py

@@ -844,7 +844,7 @@ def _analyze_remote_api(
 
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer auth login") from e
+            raise RuntimeError("Not authenticated. Run: wafer login") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e

wafer/skills/wafer-guide/SKILL.md

@@ -16,7 +16,7 @@ Before using Wafer CLI commands, install the tool:
 uv tool install wafer-cli
 
 # Authenticate (one-time setup)
-wafer auth login
+wafer login
 
 ```
 
@@ -71,31 +71,15 @@ Test correctness and measure speedup against a reference:
 wafer evaluate make-template ./my-kernel
 # Creates: kernel.py, reference.py, test_cases.json
 
-# test_cases.json format:
-# [{"name": "small", "n": 1024, "seed": 42}, {"name": "large", "n": 1048576, "seed": 42}]
-# Each dict is passed as **kwargs to generate_input() in reference.py
-
-# Run correctness check (GPUMode functional format)
-wafer evaluate gpumode \
+# Run evaluation on a configured target
+wafer evaluate \
   --impl ./my-kernel/kernel.py \
   --reference ./my-kernel/reference.py \
   --test-cases ./my-kernel/test_cases.json \
   --target <target-name>
 
-# Run correctness + benchmark (measures speedup vs reference)
-wafer evaluate gpumode \
-  --impl ./my-kernel/kernel.py \
-  --reference ./my-kernel/reference.py \
-  --test-cases ./my-kernel/test_cases.json \
-  --target <target-name> --benchmark
-
-# Run with defensive timing (detects evaluation hacking)
-wafer evaluate gpumode ... --benchmark --defensive
-
-# KernelBench format (ModelNew class)
-wafer evaluate kernelbench \
-  --impl my_kernel.py --reference problem.py \
-  --target <target-name> --stages all
+# With profiling
+wafer evaluate ... --profile
 ```
 
 ### 4. AI-Assisted Optimization
@@ -142,4 +126,4 @@ wafer config targets init runpod       # RunPod cloud GPUs
 wafer config targets init digitalocean # DigitalOcean AMD GPUs
 ```
 
-Then use: `wafer evaluate gpumode --target <name> ...`
+Then use: `wafer evaluate --target <name> ...`

wafer/ssh_keys.py

@@ -1,6 +1,6 @@
 """SSH Keys CLI - Manage SSH public keys for workspace access.
 
-This module provides the implementation for the `wafer config ssh-keys` subcommand.
+This module provides the implementation for the `wafer ssh-keys` subcommand.
 Users register their SSH public keys here, which are then installed in all
 workspaces they attach to (BYOK - Bring Your Own Key model).
 """
@@ -94,7 +94,7 @@ def list_ssh_keys(json_output: bool = False) -> str:
             keys = response.json()
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer auth login") from e
+            raise RuntimeError("Not authenticated. Run: wafer login") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
@@ -107,7 +107,7 @@ def list_ssh_keys(json_output: bool = False) -> str:
             "No SSH keys registered.\n"
             "\n"
             "Add your SSH key:\n"
-            "  wafer config ssh-keys add\n"
+            "  wafer ssh-keys add\n"
             "\n"
             "This will auto-detect your key from ~/.ssh/"
         )
@@ -149,7 +149,7 @@ def add_ssh_key(
                 "  ssh-keygen -t ed25519\n"
                 "\n"
                 "Or specify a path:\n"
-                "  wafer config ssh-keys add /path/to/key.pub"
+                "  wafer ssh-keys add /path/to/key.pub"
             )
         pubkey_path = detected[0]
 
@@ -202,7 +202,7 @@ def add_ssh_key(
             key_data = response.json()
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer auth login") from e
+            raise RuntimeError("Not authenticated. Run: wafer login") from e
         if e.response.status_code == 400:
             # Parse error detail
             try:
@@ -248,7 +248,7 @@ def remove_ssh_key(key_id: str, json_output: bool = False) -> str:
             response.raise_for_status()
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer auth login") from e
+            raise RuntimeError("Not authenticated. Run: wafer login") from e
         if e.response.status_code == 404:
             raise RuntimeError(f"SSH key not found: {key_id}") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e

wafer/targets_ops.py

@@ -15,7 +15,6 @@ import logging
 import subprocess
 from collections.abc import Callable
 from dataclasses import dataclass, replace
-from datetime import UTC
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -31,26 +30,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def _update_binding_cache(resource_id: str, spec_name: str, provider: str) -> None:
-    """Update the new target state cache when provisioning through the legacy path.
-
-    This bridges the old per-provider state files with the new unified cache
-    so that `wafer targets list` can see resources provisioned via the old flow.
-    """
-    from datetime import datetime
-
-    from wafer_core.targets.state_cache import BindingEntry, add_binding
-
-    add_binding(
-        resource_id,
-        BindingEntry(
-            spec_name=spec_name,
-            provider=provider,
-            bound_at=datetime.now(UTC).isoformat(),
-        ),
-    )
-
-
 @dataclass(frozen=True)
 class TargetSSHInfo:
     """SSH connection info for a target."""
@@ -156,8 +135,7 @@ async def _get_runpod_ssh_info(target: RunPodTarget) -> TargetSSHInfo:
     # Check if pod already exists and is running
     existing = get_pod_state(target.name)
     if existing and await check_pod_running(existing.pod_id):
-        # Reuse existing pod — also update the new state cache
-        _update_binding_cache(existing.pod_id, target.name, "runpod")
+        # Reuse existing pod
         return TargetSSHInfo(
             host=existing.public_ip,
             port=existing.ssh_port,
@@ -173,8 +151,6 @@ async def _get_runpod_ssh_info(target: RunPodTarget) -> TargetSSHInfo:
     target_keep_alive = replace(target, keep_alive=True)
 
     async with runpod_ssh_context(target_keep_alive) as ssh_info:
-        # Update new state cache with provisioned pod
-        _update_binding_cache(ssh_info.pod_id, target.name, "runpod")
         return TargetSSHInfo(
             host=ssh_info.host,
             port=ssh_info.port,
@@ -196,8 +172,7 @@ async def _get_digitalocean_ssh_info(target: DigitalOceanTarget) -> TargetSSHInf
     # Check if droplet already exists and is running
     existing = get_droplet_state(target.name)
     if existing and await check_droplet_running(existing.droplet_id):
-        # Reuse existing droplet — also update the new state cache
-        _update_binding_cache(existing.droplet_id, target.name, "digitalocean")
+        # Reuse existing droplet
         return TargetSSHInfo(
             host=existing.public_ip,
             port=22,  # DigitalOcean uses standard SSH port
@@ -209,8 +184,6 @@ async def _get_digitalocean_ssh_info(target: DigitalOceanTarget) -> TargetSSHInf
     target_keep_alive = replace(target, keep_alive=True)
 
     async with digitalocean_ssh_context(target_keep_alive) as ssh_info:
-        # Update new state cache with provisioned droplet
-        _update_binding_cache(ssh_info.droplet_id, target.name, "digitalocean")
         return TargetSSHInfo(
             host=ssh_info.host,
             port=ssh_info.port,