Merge pull request #524 from editor-code-assistant/discover-github-copilot-model-capabilities

Discover GitHub Copilot model capabilities

Author: zikajk

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Discover GitHub Copilot model APIs and reasoning variants from its authenticated `/models` endpoint.
+
 ## 0.145.1
 
 - Notify in chat when instructions change mid-chat (prompt, contexts, rules, skills, tools), invalidating the prompt cache.

docs/config/variants.md

@@ -10,7 +10,7 @@ Variants are named payload presets for a model, allowing you to quickly switch b
 
 ## Built-in Variants
 
-ECA ships with built-in variants for some known models via the `variantsByModel` config which has a good default.
+ECA ships with built-in variants for some known models via the `variantsByModel` config which has a good default. For authenticated GitHub Copilot, ECA uses only the model's advertised reasoning capabilities from Copilot's `/models` endpoint and does not guess variants when that metadata is unavailable.
 
 !!! note
 

integration-test/integration/eca.clj

@@ -36,6 +36,7 @@ If `*http-proxy*` is set, passes it as the `HTTP_PROXY` environment variable."
     (println :--eca.integration.start-server/starting :cmd cmd-full :log-path log-path :http-proxy *http-proxy*)
     (p/process cmd-full
                (cond-> {:err  log-path
+                        :extra-env {"XDG_CACHE_HOME" (str (fs/path *eca-out-dir* "cache"))}
                         :exit-fn (fn [{:keys [cmd exit]}]
                                    (when (not= exit 0)
                                      (println :--eca.integration.start-server/exited :cmd cmd :exit-status exit)
@@ -44,7 +45,7 @@ If `*http-proxy*` is set, passes it as the `HTTP_PROXY` environment variable."
                                        (catch Exception _e))
                                      (System/exit exit)))}
                  *http-proxy*
-                 (assoc :extra-env {"HTTP_PROXY" *http-proxy*})))))
+                 (assoc-in [:extra-env "HTTP_PROXY"] *http-proxy*)))))
 
 (defn start-process! []
   (let [server (start-server *eca-binary-path*)

src/eca/config.clj

@@ -218,8 +218,10 @@
               :readFile {:maxLines 2000}
               :shellCommand {:summaryMaxLength 35}
               :outputTruncation {:lines 2000 :sizeKb 50}}
-   :variantsByModel {".*sonnet[-._]4[-._]6|opus[-._]4[-._][56]" {:variants anthropic-variants}
-                     ".*opus[-._]4[-._][78]|.*sonnet[-._]5|.*fable[-._]5|.*mythos[-._]5" {:variants anthropic-v2-variants}
+   :variantsByModel {".*sonnet[-._]4[-._]6|opus[-._]4[-._][56]" {:variants anthropic-variants
+                                                                  :api ["anthropic" "bedrock"]}
+                     ".*opus[-._]4[-._][78]|.*sonnet[-._]5|.*fable[-._]5|.*mythos[-._]5" {:variants anthropic-v2-variants
+                                                                                          :api ["anthropic" "bedrock"]}
                      ".*gpt[-._]5(?:[-._](?:2|4|5)(?!\\d)|[-._]3[-._]codex)" {:variants openai-variants
                                                                               :excludeProviders ["github-copilot"]}
                      ".*gpt[-._]5[-._]6(?!\\d)" {:variants openai-gpt-5-6-variants
@@ -282,32 +284,31 @@
       false)))
 
 (defn effective-model-variants
-  "Returns effective variants for a model by merging built-in variants (from
-   :variantsByModel regex matching on the model key) with user-defined variants.
-   User-defined variants override built-in ones on name clash.
-   A variant set to {} is removed from the result, allowing users to disable
-   built-in variants."
-  [config provider model-name user-variants]
-  (let [provider-api (get-in config [:providers provider :api])
-        api-match? (fn [api config-val]
-                     (cond (sequential? config-val) (some #{api} config-val)
-                           config-val (= api config-val)
-                           :else true))
-        builtin (when model-name
-                  (some (fn [[pattern-str {:keys [variants excludeProviders api]}]]
-                          (when (and (regex-matches? pattern-str model-name)
-                                     (not (some #{provider} excludeProviders))
-                                     (api-match? provider-api api))
-                            variants))
-                        (:variantsByModel config)))
-        merged (cond
-                 (and builtin user-variants) (merge builtin user-variants)
-                 builtin builtin
-                 :else user-variants)]
-    (when merged
-      (let [filtered (into {} (remove (fn [[_ v]] (= {} v))) merged)]
-        (when (seq filtered)
-          filtered)))))
+  "Returns effective variants for a model. Built-in regex variants are the
+   fallback, discovered provider variants override them, and user variants have
+   final priority. A variant set to {} is removed from the result."
+  ([config provider model-name user-variants]
+   (effective-model-variants config provider model-name nil user-variants))
+  ([config provider model-name model-capabilities user-variants]
+   (let [provider-api (or (some-> (:api model-capabilities) name)
+                          (get-in config [:providers provider :api]))
+         api-match? (fn [api config-val]
+                      (cond (sequential? config-val) (some #{api} config-val)
+                            config-val (= api config-val)
+                            :else true))
+         builtin (when model-name
+                   (some (fn [[pattern-str {:keys [variants excludeProviders api]}]]
+                           (when (and (regex-matches? pattern-str model-name)
+                                      (not (some #{provider} excludeProviders))
+                                      (api-match? provider-api api))
+                             variants))
+                         (:variantsByModel config)))
+         merged (merge (or (not-empty (:variants model-capabilities)) builtin)
+                       user-variants)]
+     (when (seq merged)
+       (let [filtered (into {} (remove (fn [[_ v]] (= {} v))) merged)]
+         (when (seq filtered)
+           filtered))))))
 
 (defn selectable-variant-names
   "Returns sorted variant names suitable for UI display, excluding internal-only
@@ -826,11 +827,12 @@
                                config)
            agent-config (get-in config [:agent default-agent-name])
            [provider model-name] (shared/full-model->provider+model full-model)
+           model-capabilities (get-in @db* [:models full-model])
            user-variants (when (and provider model-name)
                            (get-in config [:providers provider :models model-name :variants]))
            variants (when (and provider model-name)
                       (selectable-variant-names
-                       (effective-model-variants config provider model-name user-variants)))
+                       (effective-model-variants config provider model-name model-capabilities user-variants)))
            agent-variant (:variant agent-config)
            valid? (fn [v] (and v variants (some #{v} variants)))
            select-variant (cond

src/eca/features/chat.clj

@@ -631,7 +631,8 @@
    opaque ids the new provider would reject and triggers a chat-visible
    notice via `:on-history-sanitized`. This used to throw outright (#209)."
   [db chat-id provider model config]
-  (let [current-api (:api (llm-api/provider->api-handler provider model config))
+  (let [model-capabilities (get-in db [:models (str provider "/" model)])
+        current-api (:api (llm-api/provider->api-handler provider model model-capabilities config))
         last-api (get-in db [:chats chat-id :last-api])]
     (when (and last-api current-api (not= last-api current-api))
       (logger/info logger-tag
@@ -837,7 +838,7 @@
             ;; eca.llm-api so a later swap to a different model can drop entries
             ;; whose opaque ids (Anthropic signatures, OpenAI rs_*/encrypted_content,
             ;; toolu_*/call_* tool ids) the new provider would reject. #209
-            current-api (:api (llm-api/provider->api-handler provider model config))
+            current-api (:api (llm-api/provider->api-handler provider model model-capabilities config))
             add-to-history! (fn [{:keys [role content] :as msg}]
                               (let [with-ts (update msg :created-at #(or % (System/currentTimeMillis)))
                                     tagged (if (and current-api
@@ -990,7 +991,7 @@
                                               (doseq [message user-messages]
                                                 (add-to-history!
                                                  (assoc message :content-id (:user-content-id chat-ctx))))
-                                              (swap! db* assoc-in [:chats chat-id :last-api] (:api (llm-api/provider->api-handler provider model config)))
+                                              (swap! db* assoc-in [:chats chat-id :last-api] (:api (llm-api/provider->api-handler provider model model-capabilities config)))
                                               (lifecycle/send-content! chat-ctx :system {:type :progress
                                                                                          :state :running
                                                                                          :text "Generating"}))

src/eca/features/tools/agent.clj

@@ -111,14 +111,15 @@
 
 (defn ^:private model-variant-names
   "Returns sorted variant names for a specific full model string (e.g. \"anthropic/claude-sonnet-4-6\")."
-  [config ^String full-model]
+  [config db ^String full-model]
   (when full-model
     (let [idx (.indexOf full-model "/")]
       (when (pos? idx)
         (let [provider (subs full-model 0 idx)
               model (subs full-model (inc idx))
+              model-capabilities (get-in db [:models full-model])
               user-variants (get-in config [:providers provider :models model :variants])
-              variants (config/effective-model-variants config provider model user-variants)]
+              variants (config/effective-model-variants config provider model model-capabilities user-variants)]
           (config/selectable-variant-names variants))))))
 
 (defn ^:private spawn-agent
@@ -177,7 +178,7 @@
         ;; configured variants accept any variant (the LLM API will reject if invalid).
         user-variant (get arguments "variant")
         _ (when user-variant
-            (let [valid-variants (model-variant-names config subagent-model)]
+            (let [valid-variants (model-variant-names config db subagent-model)]
               (when (and (seq valid-variants)
                          (not (some #{user-variant} valid-variants)))
                 (throw (ex-info (format "Variant '%s' is not available for model '%s'. Available variants: %s"

src/eca/handlers.clj

@@ -22,17 +22,16 @@
 (set! *warn-on-reflection* true)
 
 (defn ^:private model-variants
-  "Returns sorted variant names for a full model (e.g. \"anthropic/claude-sonnet-4-5\")
-   by resolving effective variants: built-in (from :variantsByModel regex match)
-   merged with user-defined [:providers provider :models model :variants]."
-  ^clojure.lang.IPersistentVector [config ^String full-model]
+  "Returns sorted built-in, discovered, and user-defined variant names for a full model."
+  ^clojure.lang.IPersistentVector [config db ^String full-model]
   (when full-model
     (let [idx (.indexOf full-model "/")]
       (when (pos? idx)
         (let [provider (subs full-model 0 idx)
               model (subs full-model (inc idx))
+              model-capabilities (get-in db [:models full-model])
               user-variants (get-in config [:providers provider :models model :variants])
-              variants (config/effective-model-variants config provider model user-variants)]
+              variants (config/effective-model-variants config provider model model-capabilities user-variants)]
           (config/selectable-variant-names variants))))))
 
 (defn ^:private select-variant
@@ -93,7 +92,7 @@
                                                                                 (:defaultAgent fresh-config))
                                                                             fresh-config)
                                                         default-agent-config (get-in fresh-config [:agent default-agent-name])
-                                                        variants (model-variants fresh-config default-model)]
+                                                        variants (model-variants fresh-config db default-model)]
                                                     (config/notify-fields-changed-only!
                                                      {:chat
                                                       ;; Advertise the default trust only when enabled, so clients
@@ -416,7 +415,7 @@
   ([agent-config config messenger db* chat-id]
    (when-let [model (or (:defaultModel agent-config)
                         (:defaultModel config))]
-     (let [variants (model-variants config model)
+     (let [variants (model-variants config @db* model)
            agent-variant (select-variant agent-config variants)
            ;; CAS: only mutate the chat record if it still exists at swap
            ;; time, avoiding TOCTOU resurrection when chat/delete races us.
@@ -482,7 +481,7 @@
                               (or (:defaultAgent (:chat config))
                                   (:defaultAgent config))
                               config)
-          variants (model-variants config model)
+          variants (model-variants config @db* model)
           ;; CAS: only mutate the chat record if it still exists at swap
           ;; time, avoiding TOCTOU resurrection when chat/delete races us.
           [old-db _new-db] (when chat-id