1 files changed, 76 insertions, 0 deletions
diff --git a/internal/lsp/completion_service.go b/internal/lsp/completion_service.go
new file mode 100644
index 0000000..5bfa131
--- /dev/null
+++ b/internal/lsp/completion_service.go
@@ -0,0 +1,76 @@
+package lsp
+
+import (
+	"context"
+)
+
+// completionService owns the entire code-completion subsystem that used to be
+// scattered across Server. It bundles the completion cache/throttle state
+// (completionState) with the request-handling logic, and reaches back into the
+// Server (via srv) for shared infrastructure such as configuration, LLM
+// clients, document access and stats counters.
+//
+// Splitting this out of Server keeps the completion logic cohesive and lets the
+// completionState mutex stay private to this subsystem, independent of
+// Server.mu (the two locks are never held simultaneously).
+type completionService struct {
+	srv *Server
+	completionState
+}
+
+// newCompletionService constructs the completion subsystem bound to srv.
+func newCompletionService(srv *Server) *completionService {
+	return &completionService{
+		srv:             srv,
+		completionState: newCompletionState(),
+	}
+}
+
+// waitForThrottle gates completion (and chat) LLM calls using the configured
+// throttle interval. It lives here because the throttle clock is part of the
+// completion state.
+func (cs *completionService) waitForThrottle(ctx context.Context) bool {
+	return cs.completionState.waitForThrottle(ctx, cs.srv.completionThrottle())
+}
+
+// completionSvc returns the completion subsystem, lazily constructing it for
+// the bare Server literals used in some tests. Production code always has it
+// wired up by NewServer.
+func (s *Server) completionSvc() *completionService {
+	if s.completion == nil {
+		s.completion = newCompletionService(s)
+	}
+	return s.completion
+}
+
+// --- Server delegation shims ---------------------------------------------
+// These keep existing Server call sites (and tests) working while the real
+// state and behavior live on completionService.
+
+func (s *Server) storePendingCompletion(key string, items []CompletionItem) {
+	s.completionSvc().storePendingCompletion(key, items)
+}
+
+func (s *Server) setCompletionsDisabled(disabled bool) bool {
+	return s.completionSvc().setCompletionsDisabled(disabled)
+}
+
+func (s *Server) completionDisabled() bool {
+	return s.completionSvc().completionDisabled()
+}
+
+func (s *Server) takePendingCompletion(key string) []CompletionItem {
+	return s.completionSvc().takePendingCompletion(key)
+}
+
+func (s *Server) completionCacheGet(key string) (string, bool) {
+	return s.completionSvc().cacheGet(key)
+}
+
+func (s *Server) completionCachePut(key, value string) {
+	s.completionSvc().cachePut(key, value)
+}
+
+func (s *Server) waitForThrottle(ctx context.Context) bool {
+	return s.completionSvc().waitForThrottle(ctx)
+}