[Internal] Use resolved host type from host metadata in HostType() (#1606)

## Summary

`HostType()` now returns the host type resolved from the
`/.well-known/databricks-config`
metadata endpoint when available, falling back to URL pattern matching
only when
  metadata has not been resolved.

  ## Why

PR #1596 added `HostType` to the host metadata response and stores it in
`Config.resolvedHostType` during resolution. Adding support for the host
type metadata in HostType()

  ## What changed

  ### Interface changes

None. `HostType()` still returns `HostType` with the same possible
values.

  ### Behavioral changes

- **`HostType()` now returns all resolved host types** (`WorkspaceHost`,
`AccountHost`, `UnifiedHost`) from metadata when `resolvedHostType` is
not
    `HostTypeUnknown`.
- The metadata check takes priority over **all** existing fallback
logic,
including the `Experimental_IsUnifiedHost` flag and URL pattern
matching.
  - When metadata is unavailable, behavior is identical to before.

  ### Internal changes

- Added `resolvedHostType` check at the top of `HostType()` in
`config/config.go`.
  - Updated docstring to reflect the new resolution order.

  ## How is this tested?

  Added 7 new unit tests in `config/config_test.go`:
  - Metadata workspace/account/unified types override URL patterns
- Falls back to URL matching when metadata is `HostTypeUnknown`
(workspace + account URLs)
  - Metadata takes priority over `Experimental_IsUnifiedHost` flag
- End-to-end: `EnsureResolved()` with mocked metadata → `HostType()`
returns server value

Author: tanmay-db

NEXT_CHANGELOG.md

@@ -23,6 +23,7 @@
 
 ### Internal Changes
 
+ * Use resolved host type from host metadata in `HostType()` method, falling back to URL pattern matching when metadata is unavailable.
  * Normalize internal token sources on `auth.TokenSource` for proper context propagation ([#1577](https://github.com/databricks/databricks-sdk-go/pull/1577)).
  * Fix `TestAzureGithubOIDCCredentials` hang caused by missing `HTTPTransport` stub: `EnsureResolved` now calls `resolveHostMetadata`, which makes a real network request when no transport is set ([#1550](https://github.com/databricks/databricks-sdk-go/pull/1550)).
  * Bump golang.org/x/crypto from 0.21.0 to 0.45.0 in /examples/slog ([#1566](https://github.com/databricks/databricks-sdk-go/pull/1566)).

config/config.go

@@ -447,9 +447,19 @@ func normalizedHost(host string) string {
 }
 
 // HostType returns the type of host that the client is configured for.
-// HostType now only returns WorkspaceHost or AccountHost. UnifiedHost is
-// deprecated; host metadata resolution handles unified host behavior.
+// When host metadata has been resolved (via /.well-known/databricks-config),
+// the resolved host type is returned directly. Otherwise, the host type is
+// inferred from URL patterns as a fallback.
+//
+// Deprecated: The SDK is moving towards host-agnostic behavior where host URL
+// patterns are no longer used to determine client capabilities. This method is
+// retained for backwards compatibility but should not be used in new code.
 func (c *Config) HostType() HostType {
+	// If host metadata resolved a known host type, use it.
+	if c.resolvedHostType != HostTypeUnknown {
+		return c.resolvedHostType
+	}
+
 	// TODO: Remove this after TF updates its code.
 	if c.Experimental_IsUnifiedHost {
 		return UnifiedHost

config/config_test.go

@@ -85,6 +85,75 @@ func TestHostType_UnifiedFlagNoLongerReturnsUnified(t *testing.T) {
 	assert.Equal(t, WorkspaceHost, c.HostType())
 }
 
+func TestHostType_UsesMetadataFirst_Workspace(t *testing.T) {
+	c := &Config{
+		Host:             "https://accounts.cloud.databricks.com",
+		resolvedHostType: WorkspaceHost,
+	}
+	assert.Equal(t, WorkspaceHost, c.HostType())
+}
+
+func TestHostType_UsesMetadataFirst_Account(t *testing.T) {
+	c := &Config{
+		Host:             "https://my-workspace.cloud.databricks.com",
+		resolvedHostType: AccountHost,
+	}
+	assert.Equal(t, AccountHost, c.HostType())
+}
+
+func TestHostType_UsesMetadataFirst_Unified(t *testing.T) {
+	c := &Config{
+		Host:             "https://my-workspace.cloud.databricks.com",
+		resolvedHostType: UnifiedHost,
+	}
+	assert.Equal(t, UnifiedHost, c.HostType())
+}
+
+func TestHostType_FallsBackToURLWhenMetadataUnknown(t *testing.T) {
+	c := &Config{
+		Host:             "https://accounts.cloud.databricks.com",
+		resolvedHostType: HostTypeUnknown,
+	}
+	assert.Equal(t, AccountHost, c.HostType())
+}
+
+func TestHostType_FallsBackToURLWhenMetadataUnknown_Workspace(t *testing.T) {
+	c := &Config{
+		Host:             "https://my-workspace.cloud.databricks.com",
+		resolvedHostType: HostTypeUnknown,
+	}
+	assert.Equal(t, WorkspaceHost, c.HostType())
+}
+
+func TestHostType_MetadataOverridesExperimentalFlag(t *testing.T) {
+	c := &Config{
+		Host:                       "https://my-workspace.cloud.databricks.com",
+		Experimental_IsUnifiedHost: true,
+		resolvedHostType:           AccountHost,
+	}
+	assert.Equal(t, AccountHost, c.HostType())
+}
+
+func TestHostType_EndToEnd_MetadataResolvesHostType(t *testing.T) {
+	noopLoader := mockLoader(func(cfg *Config) error { return nil })
+	cfg := &Config{
+		Host:    "https://my-workspace.cloud.databricks.com",
+		Loaders: []Loader{noopLoader},
+		HTTPTransport: fixtures.SliceTransport{
+			{
+				Method:       "GET",
+				Resource:     "/.well-known/databricks-config",
+				ReuseRequest: true,
+				Status:       200,
+				Response:     `{"oidc_endpoint": "https://my-workspace.cloud.databricks.com/oidc", "account_id": "` + testHMAccountID + `", "host_type": "account"}`,
+			},
+		},
+	}
+	err := cfg.EnsureResolved()
+	require.NoError(t, err)
+	assert.Equal(t, AccountHost, cfg.HostType())
+}
+
 func TestIsAccountClient_NoLongerPanicsOnUnifiedHost(t *testing.T) {
 	c := &Config{
 		Host:      "https://unified.cloud.databricks.com",