Anthropic subscription support, via /login anthropic command.

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Anthropic subscription support, via `/login anthropic` command.
+
 ## 0.34.2
 
 - Fix copilot requiring login in different workspaces.

deps.edn

@@ -9,6 +9,7 @@
         babashka/process {:mvn/version "0.6.23"}
         com.cognitect/transit-clj {:mvn/version "1.0.333"}
         hato/hato {:mvn/version "1.0.0"}
+        ring/ring-codec {:mvn/version "1.3.0"}
         camel-snake-kebab/camel-snake-kebab {:mvn/version "0.4.3"}
         org.slf4j/slf4j-simple {:mvn/version "2.0.17"}
         com.googlecode.java-diff-utils/diffutils {:mvn/version "1.3.0"}

src/eca/features/commands.clj

@@ -152,7 +152,7 @@
                                      (if error
                                        [error true]
                                        [message]))
-                                   ["Inform the provider-id (Ex: github-copilot)" true])]
+                                   ["Inform the provider-id (Ex: anthropic, github-copilot)" true])]
                 {:type :chat-messages
                  :status (when-not error? :login)
                  :skip-finish? true

src/eca/features/login.clj

@@ -1,24 +1,59 @@
 (ns eca.features.login
   (:require
+   [clojure.string :as string]
    [eca.db :as db]
+   [eca.llm-providers.anthropic :as llm-providers.anthropic]
    [eca.llm-providers.copilot :as llm-providers.copilot]
    [eca.messenger :as messenger]))
 
 (defn start-login [chat-id provider db*]
   (case provider
+    "anthropic"
+    (let [{:keys [verifier url]} (llm-providers.anthropic/oauth-url :console)]
+      (swap! db* assoc-in [:chats chat-id :login-provider] provider)
+      (swap! db* assoc-in [:auth provider] {:step :login/waiting-provider-code
+                                            :verifier verifier})
+      {:message (format "Open your browser at `%s` and authenticate at Anthropic.\nThen paste the code generated in the chat and send it to continue the authentication."
+                        url)})
     "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)})))
+                        user-code)})
+    {:message "Unknown provider-id"}))
 
-(defn continue [{:keys [chat-id request-id]} db* messenger]
+(defn continue [{:keys [message 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-provider-code
+      (case provider
+        "anthropic" (let [provider-code (string/trim message)
+                          {:keys [access-token refresh-token expires-at]} (llm-providers.anthropic/oauth-credentials provider-code (get-in @db* [:auth provider :verifier]))
+                          api-key (llm-providers.anthropic/create-api-key access-token)]
+                      (swap! db* update-in [:auth provider] merge {:step :login/done
+                                                                   :access-token access-token
+                                                                   :refresh-token refresh-token
+                                                                   :api-token api-key
+                                                                   :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 "Login successful! You can now use the 'anthropic' models."}})
+                      (messenger/chat-content-received
+                       messenger
+                       {:chat-id chat-id
+                        :request-id request-id
+                        :role "system"
+                        :content {:type :progress
+                                  :state :finished}})))
       :login/waiting-user-confirmation
       (case provider
         "github-copilot" (let [access-token (llm-providers.copilot/oauth-access-token (get-in @db* [:auth provider :device-code]))

src/eca/llm_api.clj

@@ -31,8 +31,9 @@
           (string/join "\n" (subvec lines start end)))
         content))))
 
-(defn ^:private provider-api-key [provider config]
+(defn ^:private provider-api-key [provider provider-auth config]
   (or (get-in config [:providers (name provider) :key])
+      (:api-token provider-auth)
       (some-> (get-in config [:providers (name provider) :keyEnv]) config/get-env)))
 
 (defn ^:private provider-api-url [provider config]
@@ -61,9 +62,9 @@
   (let [[decision model]
         (or (when-let [config-default-model (:defaultModel config)]
               [:config-default-model config-default-model])
-            (when (provider-api-key "anthropic" config)
+            (when (provider-api-key "anthropic" (get-in db [:auth "anthropic"]) config)
               [:api-key-found "anthropic/claude-sonnet-4-20250514"])
-            (when (provider-api-key "openai" config)
+            (when (provider-api-key "openai" (get-in db [:auth "openai"]) config)
               [:api-key-found "openai/gpt-5"])
             (when (get-in db [:auth "github-copilot" :api-key])
               [:api-key-found "github-copilot/gpt-4.1"])
@@ -107,7 +108,7 @@
         provider-config (get-in config [:providers provider])
         model-config (get-in provider-config [:models model])
         extra-payload (:extraPayload model-config)
-        provider-api-key (provider-api-key provider config)
+        provider-api-key (provider-api-key provider provider-auth config)
         provider-api-url (provider-api-url provider config)
         callbacks {:on-message-received on-message-received-wrapper
                    :on-error on-error-wrapper
@@ -158,7 +159,7 @@
            :tools tools
            :extra-payload extra-payload
            :api-url provider-api-url
-           :api-key (:api-token provider-auth)
+           :api-key provider-api-key
            :extra-headers {"openai-intent" "conversation-panel"
                            "x-request-id" (str (random-uuid))
                            "vscode-sessionid" ""

src/eca/llm_providers/anthropic.clj

@@ -6,7 +6,8 @@
    [eca.llm-util :as llm-util]
    [eca.logger :as logger]
    [eca.shared :as shared :refer [assoc-some]]
-   [hato.client :as http]))
+   [hato.client :as http]
+   [ring.util.codec :as ring.util]))
 
 (set! *warn-on-reflection* true)
 
@@ -107,7 +108,8 @@
                       :temperature temperature
                       :stream true
                       :tools (->tools tools web-search)
-                      :system [{:type "text" :text instructions :cache_control {:type "ephemeral"}}]}
+                      :system [{:type "text" :text "You are Claude Code, Anthropic's official CLI for Claude."}
+                               {:type "text" :text instructions :cache_control {:type "ephemeral"}}]}
                      :thinking (when (and reason? thinking)
                                  thinking))
                     extra-payload)
@@ -194,3 +196,56 @@
       :content-block* (atom nil)
       :on-error on-error
       :on-response on-response-fn})))
+
+(def client-id "9d1c250a-e61b-44d9-88ed-5944d1962f5e")
+
+(defn oauth-url [mode]
+  (let [url (str (if (= :console mode) "https://console.anthropic.com" "https://claude.ai") "/oauth/authorize")
+        {:keys [challenge verifier]} (llm-util/generate-pkce)]
+    {:verifier verifier
+     :url (str url "?" (ring.util/form-encode {:code true
+                                               :client_id client-id
+                                               :response_type "code"
+                                               :redirect_uri "https://console.anthropic.com/oauth/code/callback"
+                                               :scope "org:create_api_key user:profile user:inference"
+                                               :code_challenge challenge
+                                               :code_challenge_method "S256"
+                                               :state verifier}))}))
+
+(defn oauth-credentials [code verifier]
+  (let [[code state] (string/split code #"#")
+        url "https://console.anthropic.com/v1/oauth/token"
+        body {:grant_type "authorization_code"
+              :code code
+              :state state
+              :client_id client-id
+              :redirect_uri "https://console.anthropic.com/oauth/code/callback"
+              :code_verifier verifier}
+        {:keys [status body]} (http/post
+                               url
+                               {:headers {"Content-Type" "application/json"}
+                                :body (json/generate-string body)
+                                :as :json})]
+    (if (= 200 status)
+      {:refresh-token (:refresh_token body)
+       :access-token (:access_token body)
+       :expires-at (+ (System/currentTimeMillis) (* 1000 (:expires_in body)))}
+      (throw (ex-info (format "Anthropic token exchange failed: %s" (pr-str body))
+                      {:status status
+                       :body body})))))
+
+(defn create-api-key [access-token]
+  (let [url "https://api.anthropic.com/api/oauth/claude_cli/create_api_key"
+        {:keys [status body]} (http/post
+                               url
+                               {:headers {"Authorization" (str "Bearer " access-token)
+                                          "Content-Type" "application/x-www-form-urlencoded"
+                                          "Accept" "application/json, text/plain, */*"}
+                                :as :json})]
+    (if (= 200 status)
+      (let [raw-key (:raw_key body)]
+        (when-not (string/blank? raw-key)
+          raw-key))
+      (throw (ex-info (format "Anthropic create API token failed: %s" (pr-str body))
+                      {:status status
+                       :body body})))))

src/eca/llm_util.clj

@@ -4,7 +4,10 @@
    [clojure.string :as string]
    [eca.logger :as logger])
   (:import
-   [java.io BufferedReader]))
+   [java.io BufferedReader]
+   [java.nio.charset StandardCharsets]
+   [java.security MessageDigest SecureRandom]
+   [java.util Base64]))
 
 (defn event-data-seq [^BufferedReader rdr]
   (letfn [(next-group []
@@ -60,3 +63,28 @@
 
 (defn log-response [tag rid event data]
   (logger/debug tag (format "[%s] %s %s" rid event data)))
+
+(defn ^:private rand-bytes
+  "Returns a random byte array of the specified size."
+  [size]
+  (let [seed (byte-array size)]
+    (.nextBytes (SecureRandom.) seed)
+    seed))
+
+(defn ^:private ->base64 [^bytes bs]
+  (.encodeToString (Base64/getEncoder) bs))
+
+(defn ^:private ->base64url [base64-str]
+  (-> base64-str (string/replace "+" "-") (string/replace "/" "_")))
+
+(defn ^:private str->sha256 [^String s]
+  (-> (MessageDigest/getInstance "SHA-256")
+      (.digest (.getBytes s StandardCharsets/UTF_8))))
+
+(defn ^:private random-verifier []
+  (->base64url (->base64 (rand-bytes 63))))
+
+(defn generate-pkce []
+  (let [verifier (random-verifier)]
+    {:verifier verifier
+     :challenge (-> verifier str->sha256 ->base64 ->base64url (string/replace "=" ""))}))