Build fails with Command Line Tools only — Xcode.app should not be required

[siva-acv]

Summary

pip install (and pip install -e .) fails on systems that have Command Line Tools installed but not the full Xcode.app. The build backend explicitly rejects Command Line Tools and requires xcodebuild, but the actual build only uses swift build via Swift Package Manager — which works fine with just Command Line Tools.

Environment

• macOS 26.3 (Tahoe), Apple M3 Max
• Swift 6.2.3 (from Command Line Tools)
• xcode-select -p → /Library/Developer/CommandLineTools
• Xcode.app not installed

Error

Running pip install -e . produces:

SwiftToolingError: The active developer directory is set to Command Line Tools
(/Library/Developer/CommandLineTools), but a full Xcode installation is required.
Please install Xcode. Then open Xcode at least once to accept the license agreement
and install the Swift SDKs.

Root Cause

In build_backend.py, _build_c_bindings() performs three checks that require Xcode.app:

1. xcode-select -p path check — rejects if path contains CommandLineTools
2. xcodebuild existence check — xcodebuild binary exists in PATH but fails with: "tool 'xcodebuild' requires Xcode, but active developer directory is a command line tools instance"
3. xcodebuild -version parse — requires Xcode version >= 26.0

However, the actual compilation (lines 74-81) only uses:

subprocess.run(["swift", "build", "-c", swift_build_config], ...)

This is a pure Swift Package Manager build — it does not invoke xcodebuild at all. The Swift toolchain from Command Line Tools is sufficient.

Workaround

Removing the Xcode checks from build_backend.py (lines 71-131 in the original) allows the build to succeed:

# Replace the xcode-select + xcodebuild checks with just:
# (swift is already checked above)

After this change, pip install -e . completes successfully and the SDK works correctly (text generation, streaming, guided generation, tool calling all verified).

Suggested Fix

Either:

• Remove the Xcode.app requirement entirely, since swift build doesn't need it
• Make it a warning instead of an error, so users with Command Line Tools can still proceed
• Check for Swift SDK availability directly (e.g., swift sdk list or check for the macOS SDK) rather than using Xcode.app as a proxy

The macOS version check and swift executable check should remain — those are genuine requirements.

[siva-acv]

Proposed Fix

Replace the Xcode.app checks (xcode-select -p, xcodebuild -version) with a Swift toolchain version check that works with both Command Line Tools and Xcode.app installations.

Diff

-    # Check if xcode-select points to a full Xcode installation (not just Command Line Tools)
+    # Check Swift version >= 6.2 (ships with macOS 26 SDK support)
+    # This works with both Xcode.app and Command Line Tools installations.
     try:
-        developer_dir = subprocess.run(
-            ["xcode-select", "-p"],
+        swift_version_output = subprocess.run(
+            ["swift", "--version"],
             check=True,
             capture_output=True,
             text=True,
         ).stdout.strip()
 
-        if "CommandLineTools" in developer_dir:
-            raise SwiftToolingError(...)
-    except subprocess.CalledProcessError as e:
-        raise SwiftToolingError(...)
-
-    # Check if Xcode is installed and version >= 26.0
-    if shutil.which("xcodebuild") is None:
-        raise SwiftToolingError(...)
-
-    try:
-        xcode_version_output = subprocess.run(
-            ["xcodebuild", "-version"], ...
-        ).stdout.strip()
-
-        version_match = re.search(r"Xcode\s+(\d+)\.(\d+)", xcode_version_output)
-        ...
-        if major_version < 26:
-            raise SwiftToolingError(...)
-    except subprocess.CalledProcessError as e:
-        ...
+        version_match = re.search(r"Swift\s+version\s+(\d+)\.(\d+)", swift_version_output)
+        if not version_match:
+            raise SwiftToolingError(
+                f"Could not parse Swift version from: {swift_version_output}"
+            )
+
+        swift_major = int(version_match.group(1))
+        swift_minor = int(version_match.group(2))
+
+        if swift_major < 6 or (swift_major == 6 and swift_minor < 2):
+            raise SwiftToolingError(
+                f"Swift version {swift_major}.{swift_minor} found, but version 6.2 or higher is required. "
+                "Please update your Command Line Tools or Xcode installation."
+            )
+    except subprocess.CalledProcessError as e:
+        raise SwiftToolingError(
+            f"Failed to check Swift version: {e.stderr if e.stderr else str(e)}"
+        )

Why this works

• The build uses swift build (Swift Package Manager), not xcodebuild — so Xcode.app was never actually needed
• Swift 6.2+ ships with the macOS 26 SDK, which is the real requirement
• swift --version works identically on both Command Line Tools and Xcode.app setups
• The existing macOS version check (>= 26.0) and swift executable check are preserved

Tested on

• macOS 26.3, M3 Max
• Command Line Tools only (xcode-select -p → /Library/Developer/CommandLineTools)
• Swift 6.2.3
• pip install -e . succeeds, SDK loads and all features work (text gen, streaming, guided generation, tool calling)

Happy to open a PR if this approach looks good.