Add config/updated notification

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- New server notification `config/updated` used to notify clients when a relevant config changed (behaviors, models etc).
+- Deprecate info inside `initialize` response, clients should use `config/updated` now.
+
 ## 0.41.0
 
 - Improve anthropic extraPayload requirement when adding models.

docs/protocol.md

@@ -149,33 +149,7 @@ type ChatBehavior = 'agent' | 'plan';
 _Response:_
 
 ```typescript
-interface InitializeResponse {
-    
-    /*
-     * The models supported by the server.
-     */
-    models: ChatModel[];
-    
-    /*
-     * Default model used by server.
-     */
-    chatDefaultModel: ChatModel;
-    
-    /*
-     * The chat behaviors available.
-     */
-    chatBehaviors: ChatBehavior[];
-    
-    /*
-     * Default chat behavior used by server.
-     */
-    chatDefaultBehavior: ChatBehavior;
-    
-    /*
-     * The chat welcome message when chat is cleared or in a new state.
-     */
-    chatWelcomeMessage: string;
-}
+interface InitializeResponse {}
 ```
 
 ### Initialized (➡️)
@@ -1044,6 +1018,36 @@ Soon
 
 ## Configuration
 
+### Config updated (⬅️)
+
+A server notification with the new config server is considering (models, behaviors etc), usually related to config or auth changes.
+Clients should update UI accordingly, if a field is missing/null, means it has no change since last config used, so clients should ignore.
+
+_Notification:_ 
+
+* method: `config/updated`
+* params: `configUpdatedParams` defined as follows:
+
+```typescript
+interface ConfigUpdatedParams {
+    /**
+     * Configs related to chat.
+     */
+    chat?: {
+
+       /**
+        * The models the user can use in chat.
+        */
+        models?: ChatModel[];
+
+        /**
+        * The chat behaviors the user can select.
+        */
+        behaviors?: ChatBehavior[];
+    }
+}
+```
+
 ### Tool updated (⬅️)
 
 A server notification about a tool status update like a MCP or native tool.

src/eca/config.clj

@@ -10,9 +10,11 @@
    [cheshire.core :as json]
    [cheshire.factory :as json.factory]
    [clojure.core.memoize :as memoize]
+   [clojure.data :as data]
    [clojure.java.io :as io]
    [clojure.string :as string]
    [eca.logger :as logger]
+   [eca.messenger :as messenger]
    [eca.shared :as shared])
   (:import
    [java.io File]))
@@ -25,6 +27,8 @@
 (def ^:dynamic *global-config-error* false)
 (def ^:dynamic *local-config-error* false)
 
+(def ^:private listen-idle-ms 3000)
+
 (def initial-config
   {:providers {"openai" {:api "openai-responses"
                          :url "https://api.openai.com"
@@ -210,3 +214,66 @@
 
     ;; all good
     :else nil))
+
+(defn listen-for-changes! [db*]
+  (while (not (:stopping @db*))
+    (Thread/sleep ^long listen-idle-ms)
+    (let [db @db*
+          new-config (all db)
+          new-config-hash (hash new-config)]
+      (when (not= new-config-hash (:config-hash db))
+        (swap! db* assoc :config-hash new-config-hash)
+        (doseq [config-updated-fns (vals (:config-updated-fns db))]
+          (config-updated-fns new-config))))))
+
+(defn diff-keeping-vectors
+  "Like (second (clojure.data/diff a b)) but if a value is a vector, keep vector value from b.
+
+  Example1: (diff-keeping-vectors {:a 1 :b 2}  {:a 1 :b 3}) => {:b 3}
+  Example2: (diff-keeping-vectors {:a 1 :b [:bar]}  {:b [:bar :foo]}) => {:b [:bar :foo]}"
+  [a b]
+  (letfn [(diff-maps [a b]
+            (let [all-keys (set (concat (keys a) (keys b)))]
+              (reduce
+               (fn [acc k]
+                 (let [a-val (get a k)
+                       b-val (get b k)]
+                   (cond
+                     ;; Key doesn't exist in b, skip
+                     (and (contains? a k) (not (contains? b k)))
+                     acc
+
+                     ;; Key doesn't exist in a, include from b
+                     (and (not (contains? a k)) (contains? b k))
+                     (assoc acc k b-val)
+
+                     ;; Both are vectors and they differ, use the entire vector from b
+                     (and (vector? a-val) (vector? b-val) (not= a-val b-val))
+                     (assoc acc k b-val)
+
+                     ;; Both are maps, recurse
+                     (and (map? a-val) (map? b-val))
+                     (let [nested-diff (diff-maps a-val b-val)]
+                       (if (seq nested-diff)
+                         (assoc acc k nested-diff)
+                         acc))
+
+                     ;; Values are different, use value from b
+                     (not= a-val b-val)
+                     (assoc acc k b-val)
+
+                     ;; Values are the same, skip
+                     :else
+                     acc)))
+               {}
+               all-keys)))]
+    (let [result (diff-maps a b)]
+      (when (seq result)
+        result))))
+
+(defn notify-fields-changed-only! [config-updated messenger db*]
+  (let [config-to-notify (diff-keeping-vectors (:last-config-notified @db*)
+                                               config-updated)]
+    (when (seq config-to-notify)
+      (swap! db* update :last-config-notified shared/deep-merge config-to-notify)
+      (messenger/config-updated messenger config-to-notify))))

src/eca/db.clj

@@ -20,6 +20,10 @@
   {:client-info {}
    :workspace-folders []
    :client-capabilities {}
+   :config-hash nil
+   :providers-config-hash nil
+   :last-config-notified {}
+   :stopping false
    :chat-behaviors ["agent" "plan"]
    :models {}
    :mcp-clients {}

src/eca/handlers.clj

@@ -15,18 +15,18 @@
 
 (set! *warn-on-reflection* true)
 
-(defn ^:private initialize-models! [db* config]
+(defn ^:private sync-models! [db* config on-models-updated]
   (let [all-models (models/all)
-        eca-models (reduce
+        all-models (reduce
                     (fn [p [provider provider-config]]
                       (merge p
                              (reduce
                               (fn [m [model _model-config]]
                                 (let [full-model (str provider "/" model)
                                       model-capabilities (merge
                                                           (or (get all-models full-model)
-                                                              ;; we guess the capabilities from
-                                                              ;; the first model with same name
+                                                                     ;; we guess the capabilities from
+                                                                     ;; the first model with same name
                                                               (when-let [found-full-model (first (filter #(= (shared/normalize-model-name model)
                                                                                                              (shared/normalize-model-name (second (string/split % #"/" 2))))
                                                                                                          (keys all-models)))]
@@ -38,57 +38,84 @@
                               {}
                               (:models provider-config))))
                     {}
-                    (:providers config))]
-    (swap! db* update :models merge eca-models))
-  (when-let [ollama-models (seq (llm-api/extra-models config))]
-    (let [models (reduce
-                  (fn [models {:keys [model] :as ollama-model}]
-                    (assoc models
-                           (str config/ollama-model-prefix model)
-                           (select-keys ollama-model [:tools :reason?])))
-                  {}
-                  ollama-models)]
-      (swap! db* update :models merge models))))
+                    (:providers config))
+        all-models (if-let [local-models (seq (llm-api/local-models config))]
+                     (let [models (reduce
+                                   (fn [models {:keys [model] :as ollama-model}]
+                                     (assoc models
+                                            (str config/ollama-model-prefix model)
+                                            (select-keys ollama-model [:tools :reason?])))
+                                   {}
+                                   local-models)]
+                       (swap! db* update :models merge models))
+                     all-models)]
+    (swap! db* assoc :models all-models)
+    (on-models-updated)))
 
-(defn initialize [{:keys [db* messenger]} params]
+(defn initialize [{:keys [db*]} params]
   (logger/logging-task
    :eca/initialize
    (reset! config/initialization-config* (shared/map->camel-cased-map (:initialization-options params)))
    (let [config (config/all @db*)]
+     (logger/debug "Considered config: " config)
      (swap! db* assoc
             :client-info (:client-info params)
             :workspace-folders (:workspace-folders params)
             :client-capabilities (:capabilities params))
-     (initialize-models! db* config)
      (when-not (:pureConfig config)
        (db/load-db-from-cache! db*))
-     (future
-       (Thread/sleep 1000) ;; wait chat window is open in some editors.
-       (when-let [error (config/validation-error)]
-         (messenger/chat-content-received
-          messenger
-          {:role "system"
-           :content {:type :text
-                     :text (format "\nFailed to parse '%s' config, check stderr logs, double check your config and restart\n"
-                                   error)}})))
-     (logger/debug "Considered config: " config)
-     {:models (sort (keys (:models @db*)))
-      :chat-default-model (f.chat/default-model @db* config)
-      :chat-behaviors (:chat-behaviors @db*)
-      :chat-default-behavior (or (:defaultBehavior (:chat config)) ;;legacy
-                                 (:defaultBehavior config))
-      :chat-welcome-message (or (:welcomeMessage (:chat config)) ;;legacy
-                                (:welcomeMessage config))})))
+
+     ;; Deprecated
+     ;; For backward compatibility,
+     ;; we now return chat config via `config/updated` notification.
+     (sync-models! db* config (fn []))
+     (let [db @db*]
+       {:models (sort (keys (:models db)))
+        :chat-default-model (f.chat/default-model db config)
+        :chat-behaviors (:chat-behaviors db)
+        :chat-default-behavior (or (:defaultBehavior (:chat config)) ;;legacy
+                                   (:defaultBehavior config))
+        :chat-welcome-message (or (:welcomeMessage (:chat config)) ;;legacy
+                                  (:welcomeMessage config))}))))
 
 (defn initialized [{:keys [db* messenger config]}]
+  (let [sync-models-and-notify! (fn [config]
+                                  (let [new-providers-hash (hash (:providers config))]
+                                    (when (not= (:providers-config-hash @db*) new-providers-hash)
+                                      (swap! db* assoc :providers-config-hash new-providers-hash)
+                                      (sync-models! db* config (fn []
+                                                                 (let [db @db*]
+                                                                   (config/notify-fields-changed-only!
+                                                                    {:chat
+                                                                     {:models (sort (keys (:models db)))
+                                                                      :default-model (f.chat/default-model db config)
+                                                                      :behaviors (:chat-behaviors db)
+                                                                      :default-behavior (or (:defaultBehavior (:chat config)) ;;legacy
+                                                                                            (:defaultBehavior config))
+                                                                      :welcome-message (or (:welcomeMessage (:chat config)) ;;legacy
+                                                                                           (:welcomeMessage config))}}
+                                                                    messenger
+                                                                    db*)))))))]
+    (swap! db* assoc-in [:config-updated-fns :sync-models] #(sync-models-and-notify! %))
+    (sync-models-and-notify! config))
+  (future
+    (Thread/sleep 1000) ;; wait chat window is open in some editors.
+    (when-let [error (config/validation-error)]
+      (messenger/chat-content-received
+       messenger
+       {:role "system"
+        :content {:type :text
+                  :text (format "\nFailed to parse '%s' config, check stderr logs, double check your config and restart\n"
+                                error)}}))
+    (config/listen-for-changes! db*))
   (future
     (f.tools/init-servers! db* messenger config)))
 
 (defn shutdown [{:keys [db*]}]
   (logger/logging-task
    :eca/shutdown
    (f.mcp/shutdown! db*)
-   (reset! db* db/initial-db)
+   (swap! db* assoc :stopping true)
    nil))
 
 (defn chat-prompt [{:keys [messenger db* config]} params]

src/eca/llm_api.clj

@@ -41,7 +41,7 @@
   (or (get-in config [:providers (name provider) :url])
       (some-> (get-in config [:providers (name provider) :urlEnv]) config/get-env)))
 
-(defn extra-models [config]
+(defn local-models [config]
   (let [ollama-api-url (provider-api-url "ollama" config)]
     (mapv
      (fn [{:keys [model] :as ollama-model}]

src/eca/messenger.clj

@@ -7,5 +7,6 @@
 (defprotocol IMessenger
   (chat-content-received [this data])
   (tool-server-updated [this params])
+  (config-updated [this params])
   (showMessage [this msg])
   (editor-diagnostics [this uri]))

src/eca/server.clj

@@ -98,6 +98,9 @@
   (chat-content-received [_this content]
     (lsp.server/discarding-stdout
      (lsp.server/send-notification server "chat/contentReceived" content)))
+  (config-updated [_this params]
+    (lsp.server/discarding-stdout
+     (lsp.server/send-notification server "config/updated" params)))
   (tool-server-updated [_this params]
     (lsp.server/discarding-stdout
      (lsp.server/send-notification server "tool/serverUpdated" params)))

src/eca/shared.clj

@@ -18,7 +18,9 @@
   (System/lineSeparator))
 
 (defn uri->filename [uri]
-  (let [uri (URI. uri)]
+  (let [uri (-> (URI. uri)
+                (.toASCIIString)
+                (URI.))]
     (-> uri Paths/get .toString
         ;; WINDOWS drive letters
         (string/replace #"^[a-z]:\\" string/upper-case))))