Move network layer off @MainActor isolation

[devin-ai-integration]

Summary

Removes @MainActor from the network client layer (~44 files in clients/shared/Network/). @MainActor should only isolate UI state — not networking, URL construction, or I/O. Previously, every HTTP request (including the 15-second health check) forced URLRequest construction, URL resolution, and synchronous lockfile reads onto the main thread, contributing to app hangs (LUM-457).

Why this is needed:

• Eliminates main-thread contention from all network request construction and I/O
• Aligns with Apple's concurrency model: the cooperative thread pool handles networking while @MainActor is reserved for UI mutations
• Directly addresses the Sentry AppHang stacktrace (URLRequest.init → _SwiftURL._makeCFURL)

What changed:

• Removed @MainActor from GatewayHTTPClient, HealthCheckClient, HostToolExecutor static methods, and ~40 network client protocols + structs
• Changed Task { @MainActor in → Task { in BtwClient.sendMessage() so streaming runs on the cooperative thread pool
• Made resolveConnection() async so it can safely await the @MainActor-isolated AuthService.shared.baseURL via actor hop — this cascades async to isConnectionManaged(), buildURL(), handleAuthenticationFailure(), and InteractionClient.approvalPath() (all callers were already async)

What stays @MainActor:

• EventStreamClient — stateful SSE subscriber management
• GatewayConnectionManager — ObservableObject driving UI state
• AuthService — singleton whose baseURL/configuredBaseURL is mutated from UI/settings code

Why this is safe:

• All removed clients are stateless (no stored properties = no data races)
• URLSession, UserDefaults, and Keychain APIs are thread-safe
• All ViewModel/UI callers already use await, so actor-hopping works transparently
• The only @MainActor-isolated read (AuthService.shared.baseURL) is now properly awaited behind an if/else to avoid Swift's ?? autoclosure limitation
• No logic or behavior changes — only annotation removals and async propagation

Review & Testing Checklist for Human

• Verify the Xcode build passes with strict concurrency checking — CI requires macOS runners (all checks skipped). A local Xcode build is the primary gate.
• Verify handleAuthenticationFailure() becoming async is safe — Previously synchronous (returned immediately, spawned internal Task). Now awaited from performHealthCheck(). The managed-mode early-return path (broadcast error + disconnect) is synchronous, but confirm the health check flow still behaves correctly on 401s.
• Spot-check no callers of isConnectionManaged() or buildURL() were missed — All external callers found via grep were updated, but verify no other call sites exist in platform-specific targets.
• Test end-to-end — Send a message, verify health checks succeed, try BTW streaming, open apps. Pay special attention to managed-assistant flows (session token auth) since resolveConnection() now actor-hops for baseURL.

Notes

• Addresses LUM-492 (sub-issue of LUM-457). Follow-up issues LUM-493 (lockfile I/O off main thread) and LUM-494 (image processing off DispatchQueue.main.sync) remain for separate PRs.

Link to Devin session: https://app.devin.ai/sessions/e19a9c46f61546368efaba6020397e17
Requested by: @ashleeradka

---

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add '(aside)' to your comment to have me ignore it.
• Look at CI failures and help fix them

⚙️ Control Options:

• Disable automatic comment and CI monitoring

[linear]

LUM-492 Move network layer off @MainActor isolation

Context

The entire network layer (clients/shared/Network/) has 46 files with MainActor isolation, totaling 99 @MainActor annotations. This means all HTTP request construction, URL building, and response handling runs on the main thread.

Problem

Apple's best practice is to keep networking code off the main thread. @MainActor should only be used for UI-state mutations, not for request building or I/O. The current architecture forces every network call — including the health check that runs every 15 seconds — to serialize through the main thread.

Scope

• Remove @MainActor from GatewayHTTPClient (the central HTTP client)
• Remove @MainActor from all 40+ network client structs that inherit this isolation solely because they call GatewayHTTPClient
• Keep @MainActor only where genuinely needed (e.g., GatewayConnectionManager which is an ObservableObject driving UI)
• Ensure await MainActor.run {} is used only for the final UI-state assignments

Acceptance Criteria

• GatewayHTTPClient.buildRequest(), resolveConnection(), and all HTTP methods (get, post, put, delete, patch) execute off the main thread
• Network client structs (MessageClient, ConversationClient, HealthCheckClient, etc.) no longer require @MainActor
• All existing tests pass
• No new warnings in strict concurrency mode

---

Summary: Remove inappropriate @MainActor isolation from the shared networking layer so request building and HTTP I/O do not execute/serialize on the main thread.

Key Context:

• Current network layer has 46 files and 99 @MainActor annotations, pushing URL construction/response handling onto the main thread.
• This affects all network calls, including a health check that runs every ~15 seconds, causing unnecessary main-thread contention.
• Targeted changes: de-isolate GatewayHTTPClient and downstream client structs; keep @MainActor only where UI state is mutated and use MainActor.run {} only for final assignments.

✨ Generated by Linear Issue Context Agent