Check models and configs from models.dev

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- Get models and configs from models.dev instead of hardcoding in eca.
+- Allow custom models addition via `models <modelName>` config.
+- Add `/resume` command to resume previous chats.
+
 ## 0.23.1
 
 - Fix openai reasoning not being included in messages.

docs/configuration.md

@@ -156,9 +156,19 @@ Just add to your config the `commands` pointing to `.md` files that will be sear
 }
 ```
 
-## Overriding model payloads
+## Adding models / overriding model payloads
 
-It's possible to override the payload sent to LLMs via `models <modelName> extraPayload` config, this way you can configure custom LLM settings like `temperature`, `reasoning_effort`, `verbosity` etc.
+It's possible to add new models just adding `models <yourmodel>`, example:
+
+```javascript
+{
+  "models": {
+    "o1": {}
+  }
+}
+```
+
+To override the payload sent to LLMs via `models <modelName> extraPayload` config, this way you can configure custom LLM settings like `temperature`, `reasoning_effort`, `verbosity` etc.
 This config will be merged with current default used by ECA.
 
 Example:

src/eca/config.clj

@@ -26,7 +26,16 @@
    :disabledTools []
    :mcpTimeoutSeconds 60
    :mcpServers {}
-   :models {}
+   :models {"gpt-5" {}
+            "gpt-5-mini" {}
+            "gpt-5-nano" {}
+            "gpt-4.1" {}
+            "o4-mini" {}
+            "o3" {}
+            "claude-sonnet-4-20250514" {:extraPayload {:thinking {:type "enabled" :budget_tokens 2048}}}
+            "claude-opus-4-1-20250805" {:extraPayload {:thinking {:type "enabled" :budget_tokens 2048}}}
+            "claude-opus-4-20250514" {:extraPayload {:thinking {:type "enabled" :budget_tokens 2048}}}
+            "claude-3-5-haiku-20241022" {:extraPayload {:thinking {:type "enabled" :budget_tokens 2048}}}}
    :ollama {:host "http://localhost"
             :port 11434
             :useTools true

src/eca/features/chat.clj

@@ -14,6 +14,7 @@
    [eca.llm-api :as llm-api]
    [eca.logger :as logger]
    [eca.messenger :as messenger]
+   [eca.models :as models]
    [eca.shared :as shared :refer [assoc-some]]))
 
 (set! *warn-on-reflection* true)
@@ -107,6 +108,8 @@
                                      :text "Parsing given context"}))
   (let [db @db*
         manual-approval? (get-in config [:toolCall :manualApproval] false)
+        all-models (models/all)
+        provider (get-in all-models [model :provider])
         rules (f.rules/all config (:workspace-folders db))
         refined-contexts (f.context/raw-contexts->refined contexts db)
         repo-map* (delay (f.index/repo-map db {:as-string? true}))
@@ -124,6 +127,7 @@
                                      :text "Waiting model"})
     (llm-api/complete!
      {:model model
+      :provider provider
       :model-config (get-in db [:models model])
       :user-messages user-messages
       :instructions instructions

src/eca/handlers.clj

@@ -6,36 +6,51 @@
    [eca.features.tools :as f.tools]
    [eca.features.tools.mcp :as f.mcp]
    [eca.llm-api :as llm-api]
-   [eca.logger :as logger]))
+   [eca.logger :as logger]
+   [eca.models :as models]))
 
 (set! *warn-on-reflection* true)
 
-(defn ^:private initialize-extra-models! [db* config]
-  (when-let [custom-providers (seq (:customProviders config))]
-    (swap! db* update :models merge
-           (reduce
-            (fn [models [provider {provider-models :models default-model :defaultModel}]]
-              (reduce
-               (fn [m model]
-                 (assoc m
-                        (str (name provider) "/" model)
-                        ;; TODO avoid hardcoding these capabilities
-                        {:tools true
-                         :web-search true
-                         :custom-provider? true
-                         :default-model? (= model default-model)}))
-               models
-               provider-models))
-            {}
-            custom-providers)))
+;; (:models @eca.db/db*)
+
+(def a (models/all))
+
+
+
+(defn ^:private initialize-models! [db* config]
+  (let [all-models (models/all)
+        eca-models (filter
+                     (fn [[model _config]]
+                       (get-in config [:models model]))
+                     all-models)]
+    (swap! db* update :models merge eca-models)
+    (when-let [custom-providers (seq (:customProviders config))]
+      (let [models (reduce
+                     (fn [models [provider {provider-models :models default-model :defaultModel}]]
+                       (reduce
+                         (fn [m model]
+                           (let [known-model (get all-models model)]
+                             (assoc m
+                                    (str (name provider) "/" model)
+                                    {:tools (or (:tools known-model) true)
+                                     :reason? (or (:reason? known-model) true)
+                                     :web-search (or (:web-search known-model) true)
+                                     :max-output-tokens (:max-output-tokens known-model)
+                                     :custom-provider? true
+                                     :default-model? (= model default-model)})))
+                         models
+                         provider-models))
+                     {}
+                     custom-providers)]
+        (swap! db* update :models merge 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)]
+                   (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))))
 
 (defn initialize [{:keys [db* config]} params]

src/eca/llm_api.clj

@@ -80,7 +80,7 @@
          :type "function"))
 
 (defn complete!
-  [{:keys [model model-config instructions reason? user-messages config on-first-response-received
+  [{:keys [model provider model-config instructions reason? user-messages config on-first-response-received
            on-message-received on-error on-prepare-tool-call on-tools-called on-reason on-usage-updated
            past-messages tools]}]
   (let [first-response-received* (atom false)
@@ -105,7 +105,6 @@
                 (mapv tool->llm-tool tools))
         web-search (:web-search model-config)
         max-output-tokens (:max-output-tokens model-config)
-        reason-tokens (:reason-tokens model-config)
         custom-providers (:customProviders config)
         custom-models (set (mapcat (fn [[k v]]
                                      (map #(str (name k) "/" %) (:models v)))
@@ -118,18 +117,12 @@
                    :on-reason on-reason-wrapper
                    :on-usage-updated on-usage-updated}]
     (cond
-      (contains? #{"o4-mini"
-                   "o3"
-                   "gpt-4.1"
-                   "gpt-5"
-                   "gpt-5-mini"
-                   "gpt-5-nano"} model)
+      (= "openai" provider)
       (llm-providers.openai/completion!
        {:model model
         :instructions instructions
         :user-messages user-messages
         :max-output-tokens max-output-tokens
-        :reason-tokens reason-tokens
         :reason? (and reason? (:reason? model-config))
         :past-messages past-messages
         :tools tools
@@ -139,16 +132,12 @@
         :api-key (openai-api-key config)}
        callbacks)
 
-      (contains? #{"claude-sonnet-4-0"
-                   "claude-opus-4-0"
-                   "claude-opus-4-1"
-                   "claude-3-5-haiku-latest"} model)
+      (= "anthropic" provider)
       (llm-providers.anthropic/completion!
        {:model model
         :instructions instructions
         :user-messages user-messages
         :max-output-tokens max-output-tokens
-        :reason-tokens reason-tokens
         :reason? (and reason? (:reason? model-config))
         :past-messages past-messages
         :tools tools
@@ -177,15 +166,14 @@
             provider-fn (case (:api provider-config)
                           "openai" llm-providers.openai/completion!
                           "anthropic" llm-providers.anthropic/completion!
-                          (on-error-wrapper {:msg (format "Unknown custom model %s for provider %s" (:api provider-config) provider)}))
+                          (on-error-wrapper {:message (format "Unknown custom model %s for provider %s" (:api provider-config) provider)}))
             url (or (:url provider-config) (config/get-env (:urlEnv provider-config)))
             key (or (:key provider-config) (config/get-env (:keyEnv provider-config)))]
         (provider-fn
          {:model model
           :instructions instructions
           :user-messages user-messages
           :max-output-tokens max-output-tokens
-          :reason-tokens reason-tokens
           :reason? (and reason? (:reason? model-config))
           :past-messages past-messages
           :web-search web-search
@@ -196,4 +184,4 @@
          callbacks))
 
       :else
-      (on-error-wrapper {:msg (str "ECA Unsupported model: " model)}))))
+      (on-error-wrapper {:message (str "ECA Unsupported model: " model)}))))

src/eca/llm_providers/anthropic.clj

@@ -96,11 +96,12 @@
 
 (defn completion!
   [{:keys [model user-messages temperature instructions max-output-tokens
-           api-url api-key reason? reason-tokens past-messages tools web-search extra-payload]
+           api-url api-key reason? past-messages tools web-search extra-payload]
     :or {temperature 1.0}}
    {:keys [on-message-received on-error on-reason on-prepare-tool-call on-tools-called on-usage-updated]}]
   (let [messages (concat (normalize-messages past-messages)
                          (normalize-messages user-messages))
+        thinking (:thinking extra-payload)
         body (merge (assoc-some
                      {:model model
                       :messages (add-cache-to-last-message messages)
@@ -109,9 +110,8 @@
                       :stream true
                       :tools (->tools tools web-search)
                       :system [{:type "text" :text instructions :cache_control {:type "ephemeral"}}]}
-                     :thinking (when (and reason? reason-tokens (> reason-tokens 0))
-                                 {:type "enabled"
-                                  :budget_tokens reason-tokens}))
+                     :thinking (when (and reason? thinking)
+                                 thinking))
                     extra-payload)
 
         on-response-fn

src/eca/models.clj

@@ -0,0 +1,56 @@
+(ns eca.models
+  (:require
+   [cheshire.core :as json]
+   [eca.logger :as logger]
+   [eca.shared :refer [assoc-some]]))
+
+(set! *warn-on-reflection* true)
+
+(def ^:private logger-tag "[MODELS]")
+
+(defn ^:private models-dev* []
+  (try
+    (let [response (slurp "https://models.dev/api.json")
+          data (json/parse-string response keyword)]
+      data)
+    (catch Exception e
+      (logger/error logger-tag " Error fetching models from models.dev:" (.getMessage e))
+      {})))
+
+(def ^:private models-dev (memoize models-dev*))
+
+(def ^:private one-million 1000000)
+
+(def ^:private models-with-web-search-support
+  #{"gpt-4.1"
+    "gpt-5"
+    "gpt-5-mini"
+    "gpt-5-nano"
+    "claude-sonnet-4-20250514"
+    "claude-opus-4-20250514"
+    "claude-opus-4-1-20250805"
+    "claude-3-5-haiku-20241022"})
+
+(defn all
+  "Return all known existing models with their capabilities and configs."
+  []
+  (reduce
+   (fn [m [provider provider-config]]
+     (merge m
+            (reduce
+             (fn [p [model model-config]]
+               (assoc p (name model) (assoc-some
+                                      {:provider (or (namespace model) (name provider))
+                                       :reason? (:reasoning model-config)
+                                       ;; TODO how to check for web-search mode dynamically
+                                       :web-search (contains? models-with-web-search-support (name model))
+                                       :tools (:tool_call model-config)
+                                       :max-output-tokens (-> model-config :limit :output)}
+                                      :input-token-cost (some-> (:input (:cost model-config)) float (/ one-million))
+                                      :output-token-cost (some-> (:output (:cost model-config)) float (/ one-million))
+                                      :input-cache-creation-token-cost (some-> (:cache_write (:cost model-config)) float (/ one-million))
+                                      :input-cache-read-token-cost (some-> (:cache_read (:cost model-config)) float (/ one-million)))))
+             {}
+             (:models provider-config))))
+   {}
+   (models-dev)))

src/eca/shared.clj

@@ -52,10 +52,10 @@
         {:keys [input-token-cost output-token-cost
                 input-cache-creation-token-cost input-cache-read-token-cost]} (get-in db [:models normalized-model])
         input-cost (* input-tokens input-token-cost)
-        input-cost (if input-cache-creation-tokens
+        input-cost (if (and input-cache-creation-tokens input-cache-creation-token-cost)
                      (+ input-cost (* input-cache-creation-tokens input-cache-creation-token-cost))
                      input-cost)
-        input-cost (if input-cache-read-tokens
+        input-cost (if (and input-cache-read-tokens input-cache-read-token-cost)
                      (+ input-cost (* input-cache-read-tokens input-cache-read-token-cost))
                      input-cost)]
     (when (and input-token-cost output-token-cost)