Deduplicate identical key/value pairs in user agent builder (#1718)

## Summary

`useragent.data.With()` appended every key/value pair unconditionally
and never deduplicated. When the same user-agent dimension is injected
repeatedly onto a reused or long-lived `context.Context` — for example a
caller that threads a single context across many operations — the
per-context user-agent data accumulates duplicate entries, so
`FromContext` produces a `User-Agent` string that grows without bound
(e.g. `... sdk/x sdk/x resource/y resource/y ...`). Sufficiently large
headers can be rejected or truncated downstream.

Note that `With`'s doc comment claimed it "always uses the latest value
for a given alphanumeric key", but the implementation always appended,
and existing tests rely on multiple **distinct** values per key being
preserved (e.g. multiple partners). This change keeps that behavior and
only removes exact duplicates.

## Change

`data.With()` now skips appending a key/value pair when an identical
pair is already present. Distinct values for the same key are still
preserved, so no existing behavior or tests change. The doc comment is
updated to describe the actual behavior.

## Testing

- `go test ./useragent/` — all pass, including `TestMultiplePartners`
and `TestFromContext_Custom`.
- Added `TestInContext_DeduplicatesIdenticalPairs`: 100 repeated
identical injections collapse to one entry each; distinct values still
preserved.
- `go vet ./useragent/` and `gofmt` clean.

🤖 Generated with [Claude Code](https://claude.com/claude-code).

---------

Co-authored-by: Renaud Hartert <renaud.hartert@databricks.com>

Author: Divyansh-db

NEXT_CHANGELOG.md

@@ -8,6 +8,8 @@
 
 ### Bug Fixes
 
+* Deduplicate identical key/value pairs in the user agent builder ([useragent](https://pkg.go.dev/github.com/databricks/databricks-sdk-go/useragent)), so repeatedly injecting the same dimension onto a reused `context.Context` no longer grows the `User-Agent` header without bound. Distinct values for the same key are still preserved.
+
 ### Documentation
 
 ### Internal Changes

useragent/user_agent.go

@@ -111,7 +111,10 @@ func (u info) String() string {
 
 type data []info
 
-// With always uses the latest value for a given alphanumeric key.
+// With appends the key/value pair, skipping it when an identical key/value
+// pair is already present. De-duplicating exact pairs keeps the user agent from
+// growing without bound when the same dimension is injected repeatedly onto a
+// reused context. Distinct values for the same key are still preserved.
 // Panics if key or value don't satisfy alphanumeric or semver format.
 func (d data) With(key, value string) data {
 	if err := matchAlphanum(key); err != nil {
@@ -120,6 +123,11 @@ func (d data) With(key, value string) data {
 	if err := matchAlphanumOrSemVer(value); err != nil {
 		panic(err)
 	}
+	for _, e := range d {
+		if e.Key == key && e.Value == value {
+			return d
+		}
+	}
 	return append(d, info{key, value})
 }
 

useragent/user_agent_test.go

@@ -82,3 +82,24 @@ func TestMultiplePartners(t *testing.T) {
 	assert.Contains(t, userAgent, "partner/partner1")
 	assert.Contains(t, userAgent, "partner/partner2")
 }
+
+func TestInContext_DeduplicatesIdenticalPairs(t *testing.T) {
+	// Repeatedly injecting the same key/value pair onto a reused context must
+	// not grow the user agent: this is what happened when a long-lived caller
+	// threaded one context across many operations.
+	ctx := context.Background()
+	for i := 0; i < 100; i++ {
+		ctx = InContext(ctx, "resource", "cluster")
+		ctx = InContext(ctx, "sdk", "sdkv2")
+	}
+	userAgent := FromContext(ctx)
+	assert.Equal(t, 1, strings.Count(userAgent, "resource/cluster"))
+	assert.Equal(t, 1, strings.Count(userAgent, "sdk/sdkv2"))
+
+	// Distinct values for the same key are still preserved.
+	ctx2 := InContext(context.Background(), "resource", "a")
+	ctx2 = InContext(ctx2, "resource", "b")
+	userAgent2 := FromContext(ctx2)
+	assert.Contains(t, userAgent2, "resource/a")
+	assert.Contains(t, userAgent2, "resource/b")
+}