Fix tests

Author: ericdallo

integration-test/integration/initialize_test.clj

@@ -3,8 +3,8 @@
    [clojure.test :refer [deftest is testing]]
    [integration.eca :as eca]
    [integration.fixture :as fixture]
-   [matcher-combinators.test :refer [match?]]
-   [matcher-combinators.matchers :as m]))
+   [matcher-combinators.matchers :as m]
+   [matcher-combinators.test :refer [match?]]))
 
 (eca/clean-after-test)
 
@@ -13,17 +13,22 @@
 
   (testing "initialize request with default config"
     (is (match?
-         {:models ["claude-3-5-haiku-20241022"
-                   "claude-opus-4-1-20250805"
-                   "claude-opus-4-20250514"
-                   "claude-sonnet-4-20250514"
-                   "gpt-4.1"
-                   "gpt-5"
-                   "gpt-5-mini"
-                   "gpt-5-nano"
-                   "o3"
-                   "o4-mini"]
-          :chatDefaultModel "claude-sonnet-4-20250514"
+         {:models ["anthropic/claude-3-5-haiku-20241022"
+                   "anthropic/claude-opus-4-1-20250805"
+                   "anthropic/claude-opus-4-20250514"
+                   "anthropic/claude-sonnet-4-20250514"
+                   "github-copilot/gpt-5-mini"
+                   "github-copilot/gpt-4.1"
+                   "github-copilot/gpt-4o"
+                   "github-copilot/claude-3.5-sonnet"
+                   "github-copilot/gemini-2.0-flash-001"
+                   "openai/gpt-4.1"
+                   "openai/gpt-5"
+                   "openai/gpt-5-mini"
+                   "openai/gpt-5-nano"
+                   "openai/o3"
+                   "openai/o4-mini"]
+          :chatDefaultModel "anthropic/claude-sonnet-4-20250514"
           :chatBehaviors ["agent" "plan"]
           :chatDefaultBehavior "plan"
           :chatWelcomeMessage "Welcome to ECA!\n\nType '/' for commands\n\n"}
@@ -54,18 +59,23 @@
   (eca/start-process!)
   (testing "initialize request with custom providers"
     (is (match?
-         {:models ["claude-3-5-haiku-20241022"
-                   "claude-opus-4-1-20250805"
-                   "claude-opus-4-20250514"
-                   "claude-sonnet-4-20250514"
-                   "gpt-4.1"
-                   "gpt-5"
-                   "gpt-5-mini"
-                   "gpt-5-nano"
+         {:models ["anthropic/claude-3-5-haiku-20241022"
+                   "anthropic/claude-opus-4-1-20250805"
+                   "anthropic/claude-opus-4-20250514"
+                   "anthropic/claude-sonnet-4-20250514"
+                   "github-copilot/gpt-5-mini"
+                   "github-copilot/gpt-4.1"
+                   "github-copilot/gpt-4o"
+                   "github-copilot/claude-3.5-sonnet"
+                   "github-copilot/gemini-2.0-flash-001"
                    "myCustom/bar-2"
                    "myCustom/foo-1"
-                   "o3"
-                   "o4-mini"]
+                   "openai/gpt-4.1"
+                   "openai/gpt-5"
+                   "openai/gpt-5-mini"
+                   "openai/gpt-5-nano"
+                   "openai/o3"
+                   "openai/o4-mini"]
           :chatDefaultModel "myCustom/bar-2"
           :chatBehaviors ["agent" "plan"]
           :chatDefaultBehavior "agent"

src/eca/features/chat.clj

@@ -1,48 +1,40 @@
 (ns eca.features.login
   (:require
    [eca.db :as db]
-   [eca.llm-api :as llm-api]
+   [eca.llm-providers.copilot :as llm-providers.copilot]
    [eca.messenger :as messenger]))
 
 (defn start-login [chat-id provider db*]
-  (let [{:keys [error-message auth-type] :as result} (llm-api/auth-start {:provider provider})]
-    (cond
-      error-message
-      (do
-        (swap! db* assoc-in [:chats chat-id :status] :idle)
-        {:error true
-         :message error-message})
-
-      (= :oauth/simple auth-type)
-      (do
-        (swap! db* assoc-in [:chats chat-id :login-provider] provider)
-        (swap! db* assoc-in [:auth provider] {:step :login/waiting-user-confirmation
-                                              :device-code (:device-code result)})
-        {:message (format "Open your browser at `%s` and authenticate using the code: `%s`\nThen type anything in the chat and send it to continue the authentication."
-                          (:url result)
-                          (:user-code result))}))))
+  (case provider
+    "github-copilot"
+    (let [{:keys [user-code device-code url]} (llm-providers.copilot/oauth-url)]
+      (swap! db* assoc-in [:chats chat-id :login-provider] provider)
+      (swap! db* assoc-in [:auth provider] {:step :login/waiting-user-confirmation
+                                            :device-code device-code})
+      {:message (format "Open your browser at `%s` and authenticate using the code: `%s`\nThen type anything in the chat and send it to continue the authentication."
+                        url
+                        user-code)})))
 
 (defn continue [{:keys [chat-id request-id]} db* messenger]
   (let [provider (get-in @db* [:chats chat-id :login-provider])
         step (get-in @db* [:auth provider :step])]
     (case step
       :login/waiting-user-confirmation
       (case provider
-        "github-copilot" (let [{:keys [api-token expires-at error-message]} (llm-api/auth-continue {:provider provider
-                                                                                                    :db* db*})
-                               msg (or error-message "Login successful! You can now use the 'github-copilot' models.")]
-                           (when-not error-message
-                             (swap! db* update-in [:auth provider] merge {:step :login/done
-                                                                          :api-token api-token
-                                                                          :expires-at expires-at}))
+        "github-copilot" (let [access-token (llm-providers.copilot/oauth-access-token (get-in @db* [:auth provider :device-code]))
+                               {:keys [api-token expires-at]} (llm-providers.copilot/oauth-renew-token access-token)]
+                           (swap! db* update-in [:auth provider] merge {:step :login/done
+                                                                        :access-token access-token
+                                                                        :api-token api-token
+                                                                        :expires-at expires-at})
                            (swap! db* update-in [:chats chat-id :status] :idle)
                            (messenger/chat-content-received
                             messenger
                             {:chat-id chat-id
                              :request-id request-id
                              :role "system"
                              :content {:type :text
-                                       :text msg}})
+                                       :text "Login successful! You can now use the 'github-copilot' models."}})
                            (messenger/chat-content-received
                             messenger
                             {:chat-id chat-id
@@ -51,3 +43,11 @@
                              :content {:type :progress
                                        :state :finished}}))))
     (db/update-workspaces-cache! @db*)))
+
+(defn renew-auth! [provider db*]
+  (case provider
+    "github-copilot"
+    (let [access-token (get-in @db* [:auth provider :access-token])
+          {:keys [api-token expires-at]} (llm-providers.copilot/oauth-renew-token access-token)]
+      (swap! db* update-in [:auth provider] merge {:api-token api-token
+                                                   :expires-at expires-at}))))

src/eca/features/login.clj

@@ -204,9 +204,8 @@
           :extra-payload extra-payload}
          callbacks)
 
-        (contains? custom-models model)
-        (let [[provider model] (string/split model #"/" 2)
-              provider-config (get custom-providers (keyword provider))
+        (contains? custom-models (str provider "/" model))
+        (let [provider-config (get custom-providers (keyword provider))
               provider-fn (case (:api provider-config)
                             ("openai-responses"
                              "openai") llm-providers.openai/completion!
@@ -234,26 +233,3 @@
         (on-error-wrapper {:message (str "ECA Unsupported model: " model)}))
       (catch Exception e
         (on-error-wrapper {:exception e})))))
-
-(defn auth-start [{:keys [provider]}]
-  (try
-    (case provider
-      "github-copilot" (let [auth (llm-providers.copilot/auth-url)]
-                         {:auth-type :oauth/simple
-                          :url (:url auth)
-                          :device-code (:device-code auth)
-                          :user-code (:user-code auth)})
-      {:error-message (str "Unknown provider: " provider)})
-    (catch Exception e
-      {:error-message (format "Error log into provider %s: %s" provider (.getMessage e))})))
-
-(defn auth-continue [{:keys [provider db*]}]
-  (try
-    (case provider
-      "github-copilot" (let [{:keys [api-token expires-at]} (llm-providers.copilot/auth-exchange (get-in @db* [:auth provider :device-code]))]
-                         {:api-token api-token
-                          :expires-at expires-at})
-      {:error-message (str "Unknown provider: " provider)})
-    (catch Exception e
-      (logger/error logger-tag "Error on login: " e)
-      {:error-message (format "Error log into provider %s: %s" provider (.getMessage e))})))

src/eca/llm_api.clj

@@ -14,7 +14,7 @@
    "editor-plugin-version" "eca/*"
    "editor-version" (str "eca/" (config/eca-version))})
 
-(defn auth-url []
+(defn oauth-url []
   (let [{:keys [body]} (http/post
                         "https://github.com/login/device/code"
                         {:headers (auth-headers)
@@ -25,40 +25,44 @@
      :device-code (:device_code body)
      :url (:verification_uri body)}))
 
-(defn auth-exchange [device-code]
+(defn oauth-access-token [device-code]
   (let [{:keys [status body]} (http/post
                                "https://github.com/login/oauth/access_token"
                                {:headers (auth-headers)
                                 :body (json/generate-string {:client_id client-id
                                                              :device_code device-code
                                                              :grant_type "urn:ietf:params:oauth:grant-type:device_code"})
                                 :throw-exceptions? false
-                                :as :json})
-        access-token (:access_token body)]
+                                :as :json})]
     (if (= 200 status)
-      (let [{:keys [body]} (http/get
-                            "https://api.github.com/copilot_internal/v2/token"
-                            {:headers (merge (auth-headers)
-                                             {"authorization" (str "token " access-token)})
-                             :throw-exceptions? false
-                             :as :json})]
-        (if-let [token (:token body)]
-          {:api-token token
-           :expires-at (:expires_at body)}
-          (throw (ex-info (format "Error: You may not have access to Github Copilot")
-                          {:status status
-                           :body body}))))
+      (:access_token body)
       (throw (ex-info (format "Github auth failed: %s" (pr-str body))
                       {:status status
                        :body body})))))
 
+(defn oauth-renew-token [access-token]
+  (let [{:keys [status body]} (http/get
+                               "https://api.github.com/copilot_internal/v2/token"
+                               {:headers (merge (auth-headers)
+                                                {"authorization" (str "token " access-token)})
+                                :throw-exceptions? false
+                                :as :json})]
+    (if-let [token (:token body)]
+      {:api-token token
+       :expires-at (:expires_at body)}
+      (throw (ex-info (format "Error on copilot login: %s" body)
+                      {:status status
+                       :body body})))))
+
 (comment
-  (def a (auth-url))
+  (def a (oauth-url))
   (:user-code a)
   (:device-code a)
   (:url a)
 
-  (def credentials (auth-exchange (:device-code a)))
+  (def access-token (oauth-access-token (:device-code a)))
+
+  (def credentials (oauth-renew-token access-token))
 
   (:api-token credentials)
   (:expires-at credentials))

src/eca/llm_providers/copilot.clj

@@ -10,9 +10,9 @@
 (deftest default-model-test
   (testing "Custom provider default-model? present"
     (with-redefs [config/get-env (constantly nil)]
-      (let [db {:models {"my-model" {:custom-provider? true :default-model? true}}}
+      (let [db {:models {"my-provider/my-model" {:custom-provider? true :default-model? true}}}
             config {}]
-        (is (= "my-model" (llm-api/default-model db config))))))
+        (is (= "my-provider/my-model" (llm-api/default-model db config))))))
 
   (testing "Ollama running model present"
     (with-redefs [config/get-env (constantly nil)]
@@ -26,28 +26,28 @@
     (with-redefs [config/get-env (constantly nil)]
       (let [db {:models {}}
             config {:anthropicApiKey "something"}]
-        (is (= "claude-sonnet-4-20250514" (llm-api/default-model db config))))))
+        (is (= "anthropic/claude-sonnet-4-20250514" (llm-api/default-model db config))))))
 
   (testing "Anthropic API key present in ENV"
     (with-redefs [config/get-env (fn [k] (when (= k "ANTHROPIC_API_KEY") "env-anthropic"))]
       (let [db {:models {}}
             config {}]
-        (is (= "claude-sonnet-4-20250514" (llm-api/default-model db config))))))
+        (is (= "anthropic/claude-sonnet-4-20250514" (llm-api/default-model db config))))))
 
   (testing "OpenAI API key present in config"
     (with-redefs [config/get-env (constantly nil)]
       (let [db {:models {}}
             config {:openaiApiKey "yes!"}]
-        (is (= "gpt-5" (llm-api/default-model db config))))))
+        (is (= "openai/gpt-5" (llm-api/default-model db config))))))
 
   (testing "OpenAI API key present in ENV"
     (with-redefs [config/get-env (fn [k] (when (= k "OPENAI_API_KEY") "env-openai"))]
       (let [db {:models {}}
             config {}]
-        (is (= "gpt-5" (llm-api/default-model db config))))))
+        (is (= "openai/gpt-5" (llm-api/default-model db config))))))
 
   (testing "Fallback default (no keys anywhere)"
     (with-redefs [config/get-env (constantly nil)]
       (let [db {:models {}}
             config {}]
-        (is (= "claude-sonnet-4-20250514" (llm-api/default-model db config)))))))
+        (is (= "anthropic/claude-sonnet-4-20250514" (llm-api/default-model db config)))))))

test/eca/llm_api_test.clj

@@ -32,20 +32,18 @@
                  (shared/assoc-some {} :a 1 :b)))))
 
 (deftest tokens->cost-test
-  (let [db {:models {"my-model" {:input-token-cost 0.01
-                                 :output-token-cost 0.02
-                                 :input-cache-creation-token-cost 0.005
-                                 :input-cache-read-token-cost 0.001}}}]
+  (let [db {:models {"provider/my-model" {:input-token-cost 0.01
+                                          :output-token-cost 0.02
+                                          :input-cache-creation-token-cost 0.005
+                                          :input-cache-read-token-cost 0.001}}}]
     (testing "basic input/output cost"
-      (is (= "0.70" (shared/tokens->cost 30 nil nil 20 "my-model" db))))
+      (is (= "0.70" (shared/tokens->cost 30 nil nil 20 "provider/my-model" db))))
     (testing "with cache creation tokens"
-      (is (= "0.75" (shared/tokens->cost 30 10 nil 20 "my-model" db))))
+      (is (= "0.75" (shared/tokens->cost 30 10 nil 20 "provider/my-model" db))))
     (testing "with cache read tokens"
-      (is (= "0.73" (shared/tokens->cost 30 nil 30 20 "my-model" db))))
+      (is (= "0.73" (shared/tokens->cost 30 nil 30 20 "provider/my-model" db))))
     (testing "with both cache creation and read tokens"
-      (is (= "0.78" (shared/tokens->cost 30 10 30 20 "my-model" db))))
-    (testing "accepts provider-prefixed model names"
-      (is (= "0.70" (shared/tokens->cost 30 nil nil 20 "provider/my-model" db))))
+      (is (= "0.78" (shared/tokens->cost 30 10 30 20 "provider/my-model" db))))
     (testing "returns nil when model is missing from db"
       (is (nil? (shared/tokens->cost 30 nil nil 20 "unknown" db))))
     (testing "returns nil when mandatory costs are missing"