Support provider-relative model aliases for agents

Agent defaultModel could only be a fixed full provider/model id, so the
same agent or subagent (e.g. explorer) couldn't follow the currently
selected provider across multiple providers.

Resolve model ids alias-first: a bare id is matched against the selected
provider's models (the chat's own model, or a subagent's parent chat
model) before being treated as a full id, so defining the same model name
under each provider lets one agent config work everywhere. Stored chat
models still win over agent defaults and unknown ids are kept verbatim.

Closes #501

Author: ericdallo

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - OpenAI OAuth (ChatGPT/Codex) models now report Codex context windows instead of inflated direct-API limits (e.g. gpt-5.5 272k, not 1.05M).
+- Agent `defaultModel` (and explicit model ids) resolve alias-first: a bare model id is matched against the currently selected provider's models before being treated as a full id, enabling provider-relative subagent models. (#501)
 
 ## 141.0
 

docs/config.json

@@ -815,9 +815,9 @@
         },
         "defaultModel": {
           "type": "string",
-          "description": "Default model for this agent, overriding the global default.",
-          "markdownDescription": "Default model for this agent, overriding the global default.",
-          "examples": ["anthropic/claude-sonnet-4-6"]
+          "description": "Default model for this agent, overriding the global default. May be a full provider/model id or a bare model name resolved against the currently selected provider's models (provider-relative alias).",
+          "markdownDescription": "Default model for this agent, overriding the global default. May be a full `provider/model` id or a bare model name resolved against the currently selected provider's models (provider-relative alias).",
+          "examples": ["anthropic/claude-sonnet-4-6", "explorer-small"]
         },
         "variant": {
           "type": "string",

docs/config/models.md

@@ -424,6 +424,34 @@ Examples:
 
     This way both will use gpt-5 model but one will override the reasoning to be high instead of the default.
 
+=== "Provider-relative model alias"
+
+    Define the same logical model name under multiple providers (using `modelName` to point at each provider's real model), then reference that name from an agent's `defaultModel`. A bare model id is resolved against the currently selected provider before being treated as a full id, so the same agent config follows whichever provider you switch to.
+
+    ```javascript title="~/.config/eca/config.json"
+    {
+      "providers": {
+        "github-copilot": {
+          "models": {
+            "explorer-small": { "modelName": "raptor-mini" }
+          }
+        },
+        "company-litellm": {
+          "models": {
+            "explorer-small": { "modelName": "hf-qwen3-32b-awq" }
+          }
+        }
+      },
+      "agent": {
+        "explorer": {
+          "defaultModel": "explorer-small"
+        }
+      }
+    }
+    ```
+
+    With `github-copilot` selected, the `explorer` subagent uses `github-copilot/raptor-mini`; switching to `company-litellm` makes it use `company-litellm/hf-qwen3-32b-awq` with no agent config change. Full ids like `"anthropic/claude-sonnet-4-6"` still work and are used as-is.
+
 === "Override limits & pricing (local models)"
 
     Models that models.dev doesn't know about (e.g. a local model served via an OpenAI-compatible endpoint) have no context window or pricing, so the usage display shows no upper limit and auto-compaction never triggers. Set `limit` and/or `cost` to fix this. These values override models.dev, so you can also cap a known model's context window. Costs are per 1M tokens.

src/eca/features/chat.clj

@@ -25,6 +25,7 @@
    [eca.logger :as logger]
    [eca.messenger :as messenger]
    [eca.metrics :as metrics]
+   [eca.models :as models]
    [eca.shared :as shared :refer [assoc-some future*]]))
 
 (set! *warn-on-reflection* true)
@@ -297,23 +298,37 @@
 (defn default-model [db config]
   (llm-api/default-model db config))
 
+(defn ^:private selected-provider
+  "Provider currently selected for `chat-id`, derived from the chat's own model
+   or, for subagents, its parent chat's model."
+  [db chat-id]
+  (let [model (or (get-in db [:chats chat-id :model])
+                  (when-let [parent-id (db/parent-chat-id db chat-id)]
+                    (get-in db [:chats parent-id :model])))]
+    (some-> model shared/full-model->provider+model first)))
+
 (defn ^:private resolve-full-model
-  "Resolve the full model id for a prompt response and LLM request."
+  "Resolve the full model id for a prompt response and LLM request.
+   Model ids are resolved alias-first: a bare id is matched against the currently
+   selected provider's models before being treated as a literal full model id."
   [requested-model db chat-id agent-config config]
-  (or requested-model
-      (let [stored-model (get-in db [:chats chat-id :model])
-            agent-default-model (:defaultModel agent-config)]
-        (cond
-          (and stored-model
-               (contains? (:models db) stored-model))
-          stored-model
-
-          (and agent-default-model
-               (contains? (:models db) agent-default-model))
-          agent-default-model
-
-          :else
-          (default-model db config)))))
+  (let [provider (selected-provider db chat-id)]
+    (or (when requested-model
+          (or (models/full-model-for db provider requested-model)
+              requested-model))
+        (let [stored-model (get-in db [:chats chat-id :model])
+              agent-default-model (:defaultModel agent-config)]
+          (cond
+            (and stored-model
+                 (contains? (:models db) stored-model))
+            stored-model
+
+            agent-default-model
+            (or (models/full-model-for db provider agent-default-model)
+                (default-model db config))
+
+            :else
+            (default-model db config))))))
 
 (defn ^:private update-pre-request-state
   "Pure function to compute new state from hook result."

src/eca/features/tools/agent.clj

@@ -5,7 +5,9 @@
    [eca.config :as config]
    [eca.features.tools.util :as tools.util]
    [eca.logger :as logger]
-   [eca.messenger :as messenger]))
+   [eca.messenger :as messenger]
+   [eca.models :as models]
+   [eca.shared :as shared]))
 
 (set! *warn-on-reflection* true)
 
@@ -161,7 +163,14 @@
                                  :available (available-model-names db)})))))
 
         parent-model (get-in db [:chats chat-id :model])
-        subagent-model (or user-model (:model subagent) parent-model)
+        parent-provider (some-> parent-model shared/full-model->provider+model first)
+        ;; The agent's :defaultModel may be a bare alias resolved against the
+        ;; currently selected (parent) provider; keep it verbatim if it doesn't resolve.
+        subagent-model (or user-model
+                          (when-let [agent-model (:model subagent)]
+                            (or (models/full-model-for db parent-provider agent-model)
+                                agent-model))
+                          parent-model)
 
         ;; Variant validation: reject only when the resolved model has configured
         ;; variants and the user-specified one isn't among them. Models with no

src/eca/models.clj

@@ -530,6 +530,20 @@
    {}
    (:providers config)))
 
+(defn full-model-for
+  "Resolve `model-id` to a full \"provider/model\" key present in `db`'s `:models`.
+   Checks a provider-local alias first (\"<provider>/<model-id>\", when `model-id`
+   has no provider prefix), then the literal `model-id`. Returns nil when neither
+   matches a known model."
+  [db provider model-id]
+  (when model-id
+    (let [models (:models db)
+          alias-model (when (and provider (not (string/includes? model-id "/")))
+                        (str provider "/" model-id))]
+      (cond
+        (and alias-model (contains? models alias-model)) alias-model
+        (contains? models model-id) model-id))))
+
 (defn sync-models! [db* config on-models-updated]
   (let [models-dev-data (models-dev)
         known-models (all models-dev-data)

test/eca/features/chat_test.clj

@@ -1811,4 +1811,32 @@
     (is (= {} (:chats (h/db))))
     (is (= {} (h/messages)))))
 
+(deftest resolve-full-model-alias-test
+  (let [db {:models {"company-litellm/big" {}
+                     "company-litellm/explorer-small" {}
+                     "github-copilot/explorer-small" {}
+                     "anthropic/claude-sonnet-4-6" {}}
+            :chats {"main" {:id "main" :model "company-litellm/big"}
+                    "sub" {:id "sub" :parent-chat-id "main"}}}
+        resolve-model (fn [requested chat-id agent-config]
+                        (#'f.chat/resolve-full-model requested db chat-id agent-config {}))]
+    (testing "explicit bare alias resolves against the chat's selected provider"
+      (is (= "company-litellm/explorer-small"
+             (resolve-model "explorer-small" "main" {}))))
+    (testing "subagent resolves a bare alias against its parent chat's provider"
+      (is (= "company-litellm/explorer-small"
+             (resolve-model "explorer-small" "sub" {}))))
+    (testing "agent defaultModel bare alias resolves via the selected provider"
+      (is (= "company-litellm/explorer-small"
+             (resolve-model nil "sub" {:defaultModel "explorer-small"}))))
+    (testing "a literal full model id is returned as-is"
+      (is (= "anthropic/claude-sonnet-4-6"
+             (resolve-model "anthropic/claude-sonnet-4-6" "main" {}))))
+    (testing "an unknown explicit model id is kept verbatim (back-compat)"
+      (is (= "totally-unknown"
+             (resolve-model "totally-unknown" "main" {}))))
+    (testing "a stored full model still wins over the agent defaultModel"
+      (is (= "company-litellm/big"
+             (resolve-model nil "main" {:defaultModel "explorer-small"}))))))
+
 

test/eca/features/tools/agent_test.clj

@@ -590,6 +590,39 @@
           (is (= "anthropic/claude-sonnet-4-6" (:model @chat-prompt-called*))
               "user-specified model should win over agent defaultModel"))))))
 
+(deftest spawn-agent-defaultmodel-alias-test
+  (testing "agent defaultModel bare alias resolves against the parent chat's provider"
+    (let [config-with-alias (assoc-in test-config [:agent "explorer" :defaultModel] "explorer-small")
+          db* (atom {:chats {"chat-1" {:id "chat-1" :model "company-litellm/big"}}
+                     :models {"company-litellm/big" {}
+                              "company-litellm/explorer-small" {}
+                              "github-copilot/explorer-small" {}}})
+          subagent-chat-id "subagent-tc-1"
+          chat-prompt-called* (promise)]
+      (with-redefs [requiring-resolve
+                    (fn [sym]
+                      (case sym
+                        eca.features.chat/prompt
+                        (fn [params _db* _messenger _config _metrics]
+                          (deliver chat-prompt-called* params)
+                          (swap! db* assoc-in [:chats subagent-chat-id :status] :idle)
+                          (swap! db* assoc-in [:chats subagent-chat-id :messages]
+                                 [{:role "assistant"
+                                   :content [{:type :text :text "Done."}]}]))
+                        (clojure.lang.RT/var (namespace sym) (name sym))))]
+        (let [result ((get-in (f.tools.agent/definitions config-with-alias test-db) ["spawn_agent" :handler])
+                      {"agent" "explorer" "task" "explore" "activity" "exploring"}
+                      {:db* db*
+                       :config config-with-alias
+                       :messenger (h/messenger)
+                       :metrics (h/metrics)
+                       :chat-id "chat-1"
+                       :tool-call-id "tc-1"
+                       :call-state-fn (constantly {:status :executing})})]
+          (is (match? {:error false} result))
+          (is (= "company-litellm/explorer-small" (:model @chat-prompt-called*))
+              "bare alias should resolve to the parent provider's model"))))))
+
 (deftest extract-final-summary-test
   (testing "extracts text from last assistant message"
     (is (= "Hello world"

test/eca/models_test.clj

@@ -633,3 +633,25 @@
         (let [supported (build-supported-models config {} models-dev-data)]
           (is (= "https://api.openai.com/v1/models" (first @request*)))
           (is (= 1050000 (get-in supported ["openai/gpt-5.5" :limit :context]))))))))
+
+(deftest full-model-for-test
+  (let [db {:models {"github-copilot/explorer-small" {}
+                     "company-litellm/explorer-small" {}
+                     "anthropic/claude-sonnet-4-6" {}}}]
+    (testing "resolves a bare alias against the given provider (provider-relative)"
+      (is (= "github-copilot/explorer-small"
+             (models/full-model-for db "github-copilot" "explorer-small")))
+      (is (= "company-litellm/explorer-small"
+             (models/full-model-for db "company-litellm" "explorer-small"))))
+    (testing "resolves a literal full model id"
+      (is (= "anthropic/claude-sonnet-4-6"
+             (models/full-model-for db "github-copilot" "anthropic/claude-sonnet-4-6"))))
+    (testing "returns nil when neither alias nor literal matches"
+      (is (nil? (models/full-model-for db "github-copilot" "missing")))
+      (is (nil? (models/full-model-for db "github-copilot" "openai/missing"))))
+    (testing "returns nil for a nil model id"
+      (is (nil? (models/full-model-for db "github-copilot" nil))))
+    (testing "without a provider only literal full ids resolve"
+      (is (nil? (models/full-model-for db nil "explorer-small")))
+      (is (= "anthropic/claude-sonnet-4-6"
+             (models/full-model-for db nil "anthropic/claude-sonnet-4-6"))))))