server/errors.go (1)

16-22: Align error message with existing “per-session” phrasing

Keep wording consistent with ErrSessionDoesNotSupportTools/Resources.

-ErrSessionDoesNotSupportResourceTemplates = errors.New("session does not support resource templates")
+ErrSessionDoesNotSupportResourceTemplates = errors.New("session does not support per-session resource templates")

server/streamable_http_sampling_test.go (2)

27-36: Add interface assertion for SessionWithResourceTemplates

Guard the new constructor param with a compile-time-style assertion, mirroring the sampling check.

   // Verify it implements SessionWithSampling
   _, ok := any(session).(SessionWithSampling)
   if !ok {
     t.Error("streamableHttpSession should implement SessionWithSampling")
   }
+
+  // Verify it implements SessionWithResourceTemplates
+  if _, ok := any(session).(SessionWithResourceTemplates); !ok {
+    t.Error("streamableHttpSession should implement SessionWithResourceTemplates")
+  }

---

140-148: Also assert SessionWithResourceTemplates in the interface test

Mirror the sampling assertion to cover the new capability.

   // Verify it implements SessionWithSampling
   _, ok := any(session).(SessionWithSampling)
   if !ok {
     t.Error("streamableHttpSession should implement SessionWithSampling")
   }
+
+  // Verify it implements SessionWithResourceTemplates
+  if _, ok := any(session).(SessionWithResourceTemplates); !ok {
+    t.Error("streamableHttpSession should implement SessionWithResourceTemplates")
+  }

server/sse.go (1)

31-35: Clarify key semantics for resourceTemplates

Note that the map key is the template’s URITemplate.Raw() string for consistency with server/session.go.

server/server.go (1)

883-910: Merge precedence is correct; align sort style with resources

Session templates override globals; good. Optionally use slices.SortedFunc like handleListResources for consistency.

- // Convert map to slice for sorting and pagination
- templates := make([]mcp.ResourceTemplate, 0, len(templateMap))
- for _, template := range templateMap {
-   templates = append(templates, template)
- }
- sort.Slice(templates, func(i, j int) bool {
-   return templates[i].Name < templates[j].Name
- })
+ // Convert map to slice and sort by name (consistent with resources)
+ templates := slices.SortedFunc(maps.Values(templateMap), func(a, b mcp.ResourceTemplate) int {
+   return cmp.Compare(a.Name, b.Name)
+ })

server/session.go (1)

695-751: Clarify expected identifier for deletion

Document that uriTemplates must be the URITemplate.Raw() string; optional helper to delete by mcp.ResourceTemplate could reduce footguns.

Happy to add a DeleteSessionResourceTemplateByTemplate(sessionID string, t mcp.ResourceTemplate) wrapper if helpful.

server/streamable_http.go (4)

624-631: Cleanup includes per-session templates

Templates store is cleared with other session-scoped data. Consider fixing minor typos in comments (“relateddata”, “requstID”) later.

---

840-872: Thread-safe store mirrors existing patterns; optional simplification

Implementation is correct and race-safe. Optionally, simplify cloning for readability:

-	cloned := make(map[string]ServerResourceTemplate, len(s.templates[sessionID]))
-	maps.Copy(cloned, s.templates[sessionID])
-	return cloned
+	src := s.templates[sessionID]
+	cloned := maps.Clone(src)
+	if cloned == nil {
+		cloned = make(map[string]ServerResourceTemplate)
+	}
+	return cloned

---

1004-1011: Interface conformance achieved with safe Get/Set

Get/Set delegate to the store, preserving copy-on-get semantics. Assertions cover SessionWithResourceTemplates. If helpful, add a brief comment noting Set replaces the entire map (callers should use server-level Add/Delete helpers for incremental updates).

Also applies to: 1013-1017

---

521-527: Send notification by value, not pointer

Avoid taking the address of the select-scoped variable; just send the value:

-				case writeChan <- &nt:
+				case writeChan <- nt:

This reduces escapes and keeps semantics consistent with POST path.

If you prefer to keep pointers for large payloads, confirm there’s measurable benefit and no unintended escapes in benchmarks.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

server/session_resource_templates_test.go (7)

33-39: Protect initialized flag to avoid data races (tests under -race).

Use atomic.Bool (or guard with the existing mutex). Keeps tests race-free when server goroutines read it.

 type sessionTestClientWithResourceTemplates struct {
-	sessionID                string
-	notificationChannel      chan mcp.JSONRPCNotification
-	initialized              bool
+	sessionID           string
+	notificationChannel chan mcp.JSONRPCNotification
+	initialized         atomic.Bool
 	sessionResourceTemplates map[string]ServerResourceTemplate
 	mu                       sync.RWMutex
 }
 
 func (f *sessionTestClientWithResourceTemplates) Initialize() {
-	f.initialized = true
+	f.initialized.Store(true)
 }
 
 func (f *sessionTestClientWithResourceTemplates) Initialized() bool {
-	return f.initialized
+	return f.initialized.Load()
 }

Remember to import sync/atomic in the stdlib section.

---

41-52: Simplify GetSessionResourceTemplates with maps.Clone.

Removes nil checks and manual allocation.

 func (f *sessionTestClientWithResourceTemplates) GetSessionResourceTemplates() map[string]ServerResourceTemplate {
   f.mu.RLock()
   defer f.mu.RUnlock()
-
-  if f.sessionResourceTemplates == nil {
-    return nil
-  }
-
-  templatesCopy := make(map[string]ServerResourceTemplate, len(f.sessionResourceTemplates))
-  maps.Copy(templatesCopy, f.sessionResourceTemplates)
-  return templatesCopy
+  return maps.Clone(f.sessionResourceTemplates)
 }

---

54-66: Likewise, Clone on SetSessionResourceTemplates.

Less code, same semantics.

 func (f *sessionTestClientWithResourceTemplates) SetSessionResourceTemplates(templates map[string]ServerResourceTemplate) {
   f.mu.Lock()
   defer f.mu.Unlock()
-
-  if templates == nil {
-    f.sessionResourceTemplates = nil
-    return
-  }
-
-  templatesCopy := make(map[string]ServerResourceTemplate, len(templates))
-  maps.Copy(templatesCopy, templates)
-  f.sessionResourceTemplates = templatesCopy
+  f.sessionResourceTemplates = maps.Clone(templates)
 }

---

239-245: Reduce flakiness in notification waits.

Replace repeated select+time.After with a small helper or assert/require.Eventually and slightly longer overall timeout.

Add a helper once:

func expectNotification(t *testing.T, ch <-chan mcp.JSONRPCNotification, want string, d time.Duration) mcp.JSONRPCNotification {
  t.Helper()
  select {
  case n := <-ch:
    require.Equal(t, want, n.Method)
    return n
  case <-time.After(d):
    t.Fatalf("timeout waiting for %s", want)
    return mcp.JSONRPCNotification{}
  }
}

Then call:

_ = expectNotification(t, sessionChan, "notifications/resources/list_changed", 500*time.Millisecond)

Alternatively, use require.Eventually with a non-busy poll.

Also applies to: 276-282, 317-325, 339-350, 389-399, 416-421, 512-517, 563-567, 575-579

---

475-483: Guard result before indexing and assert type.

Avoid panics and improve failure signals.

 response := server.HandleMessage(sessionCtx, requestBytes)
 resp, ok := response.(mcp.JSONRPCResponse)
 require.True(t, ok)
- readResourceResult, ok := resp.Result.(mcp.ReadResourceResult)
- assert.True(t, ok)
-
- if text := readResourceResult.Contents[0].(mcp.TextResourceContents).Text; text != "session result" {
-   t.Errorf("Expected result 'session result', got %q", text)
- }
+ readResourceResult, ok := resp.Result.(mcp.ReadResourceResult)
+ require.True(t, ok)
+ require.Len(t, readResourceResult.Contents, 1)
+ tc, ok := readResourceResult.Contents[0].(mcp.TextResourceContents)
+ require.True(t, ok)
+ assert.Equal(t, "session result", tc.Text)

---

127-218: Add read-path assertions for global usage and fallback after delete.

• After listing, also read test://another/{id} to confirm global handler is used.
• After deleting a session template, read the same URI to confirm fallback to global.

I can draft targeted tests mirroring the existing HandleMessage patterns if you want them added.

Also applies to: 487-522

---

70-582: Consider table-driven tests and t.Parallel for similar cases.

Several tests follow the same add/delete/notify pattern. Table-driven subtests with t.Parallel would cut duplication and speed runs.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro