Add Anthropic integration

Author: ericdallo

CHANGELOG.md

@@ -2,3 +2,5 @@
 
 ## Unreleased
 
+- First alpha release
+

build.clj

@@ -5,8 +5,6 @@
    [clojure.string :as string]
    [clojure.tools.build.api :as b]))
 
-(def lib 'com.github.editor-code-assistant/eca)
-(def current-version (string/trim (slurp (io/resource "ECA_VERSION"))))
 (def class-dir "target/classes")
 (def basis {:project "deps.edn"})
 (def file "target/eca.jar")

docs/protocol.md

@@ -250,6 +250,9 @@ interface ChatPromptParams {
 type ChatModel = 
     | 'o4-mini'
     | 'gpt-4.1'
+    | 'claude-sonnet-4-0'
+    | 'claude-opus-4-0'
+    | 'claude-3-5-haiku-latest'
     | "auto";
 
 type ChatContext = FileContext | DirectoryContext | WebContext | CodeContext;

src/eca/config.clj

@@ -14,6 +14,7 @@
 
 (def initial-config
   {:openai-api-key nil
+   :anthropic-api-key nil
    :index {:ignore-files [".gitignore"]}})
 
 (defn ^:private safe-read-json-string [raw-string]

src/eca/db.clj

@@ -6,7 +6,11 @@
    :client-capabilities {}
    :chats []
    :chat-behavior :agent
-   :models ["o4-mini" "gpt-4.1"]
+   :models ["o4-mini"
+            "gpt-4.1"
+            "claude-sonnet-4-0"
+            "claude-opus-4-0"
+            "claude-3-5-haiku-latest"]
    :default-model "o4-mini"})
 
 (defonce db* (atom initial-db))

src/eca/features/chat.clj

@@ -23,27 +23,23 @@
               nil))
           context))
 
-(defn ^:private behavior->prompt-input [behavior]
-  (case (keyword behavior)
-    :agent "Help suggesting what needs to be changed if requested, offering help to make itself."
-    :ask "Only answer questions and doubts."
-    :manual "Help suggesting what needs to be changed."
-    ""))
-
-(defn ^:private build-prompt [message behavior refined-context]
-  (format (str "You are an expert AI coding tool called ECA (Editor Code Assistant). Structure your answer in markdown *WITHOUT* using markdown code block.\n"
-               "Your behavior is to '%s'.\n"
-               "The user is asking: '%s'\n"
-               "Context: %s")
-          (behavior->prompt-input behavior)
-          message
-          (reduce (fn [msg {:keys [type path content-map]}]
-                    (str
-                     msg
-                     (case type
-                       :file (str path ":\n" content-map)
-                       "")
-                     "\n")) "" refined-context)))
+(defn ^:private build-context [behavior refined-context]
+  {:role (str "You are an expert AI coding tool called ECA (Editor Code Assistant).\n"
+              "Structure your answer in markdown *WITHOUT* using markdown code block.")
+   :behavior (format "Your behavior is to '%s'."
+                     (case (keyword behavior)
+                       :agent "Help suggesting what needs to be changed if requested, offering help to make itself."
+                       :ask "Only answer questions and doubts."
+                       :manual "Help suggesting what needs to be changed."
+                       ""))
+   :context (format "<context>\n%s\n</context>"
+                    (reduce (fn [msg {:keys [type path content-map]}]
+                              (str
+                               msg
+                               (case type
+                                 :file (str path ":\n" content-map)
+                                 "")
+                               "\n")) "" refined-context))})
 
 (defn prompt
   [{:keys [message model behavior contexts chat-id request-id]}
@@ -71,7 +67,8 @@
         :role :system
         :content {:type :temporary-text
                   :text "Parsing given context..."}}))
-    (let [refined-context (raw-context->refined contexts)]
+    (let [refined-contexts (raw-context->refined contexts)
+          context (build-context (or behavior (:chat-behavior @db*)) refined-contexts)]
       (messenger/chat-content-received
        messenger
        {:chat-id chat-id
@@ -81,7 +78,8 @@
         :content {:type :temporary-text
                   :text "Generating..."}})
       (llm-api/complete! {:model (or model (:default-model @db*))
-                          :message (build-prompt message (or behavior (:chat-behavior @db*)) refined-context)
+                          :user-prompt message
+                          :context context
                           :config config
                           :on-message-received (fn [{:keys [message finish-reason]}]
                                                  (messenger/chat-content-received

src/eca/llm_api.clj

@@ -1,5 +1,6 @@
 (ns eca.llm-api
   (:require
+   [eca.llm-providers.anthropic :as llm-providers.anthropic]
    [eca.llm-providers.openai :as llm-providers.openai]))
 
 (set! *warn-on-reflection* true)
@@ -8,13 +9,25 @@
   ;; TODO ask LLM for the most relevant parts of the path
   (slurp path))
 
-(defn complete! [{:keys [model message config on-message-received on-error]}]
+(defn complete! [{:keys [model context user-prompt config on-message-received on-error]}]
   (case model
     ("o4-mini"
-     "gpt-4.1") (llm-providers.openai/completion!
-                 {:model model
-                  :messages [{:role "user" :content message}]
-                  :api-key (:openai-api-key config)}
-                 {:on-message-received on-message-received
-                  :on-error on-error})
+     "gpt-4.1")
+    (llm-providers.openai/completion!
+     {:model model
+      :context context
+      :user-prompt user-prompt
+      :api-key (:openai-api-key config)}
+     {:on-message-received on-message-received
+      :on-error on-error})
+    ("claude-sonnet-4-0"
+     "claude-opus-4-0"
+     "claude-3-5-haiku-latest")
+    (llm-providers.anthropic/completion!
+     {:model model
+      :context context
+      :user-prompt user-prompt
+      :api-key (:anthropic-api-key config)}
+     {:on-message-received on-message-received
+      :on-error on-error})
     (on-error {:msg (str "ECA Unsupported model: " model)})))

src/eca/llm_providers/anthropic.clj

@@ -0,0 +1,63 @@
+(ns eca.llm-providers.anthropic
+  (:require
+   [cheshire.core :as json]
+   [clojure.java.io :as io]
+   [clojure.string :as str]
+   [eca.logger :as logger]
+   [hato.client :as http]))
+
+(def ^:private logger-tag "[ANTHROPIC]")
+
+(def ^:private url "https://api.anthropic.com/v1/messages")
+
+(defn ^:private raw-data->messages [data]
+  (let [{:keys [type delta]} (json/parse-string data true)]
+    (case type
+      "content_block_delta" (case (:type delta)
+                              "text_delta" {:message (:text delta)}
+                              (logger/warn "Unkown response delta type" (:type delta)))
+      "message_stop" {:finish-reason type}
+      nil)))
+
+(defn ^:private context->system [{:keys [role behavior context]}]
+  (format "%s\n%s\n%s\n"
+          role behavior context))
+
+(defn completion! [{:keys [model user-prompt temperature context max-tokens api-key]
+                    :or {max-tokens 1024
+                         temperature 1.0}}
+                   {:keys [on-message-received on-error]}]
+  (let [body {:model model
+              :messages [{:role "user" :content user-prompt}]
+              :max_tokens max-tokens
+              :temperature temperature
+              ;; TODO support :thinking
+              :stream true
+              :system (context->system context)}
+        api-key (or api-key
+                    (System/getenv "ANTHROPIC_API_KEY"))]
+    (http/post
+     url
+     {:headers {"x-api-key" api-key
+                "anthropic-version" "2023-06-01"
+                "Content-Type" "application/json"}
+      :body (json/generate-string body)
+      :throw-exceptions? false
+      :async? true
+      :as :stream}
+     (fn [{:keys [status body]}]
+       (try
+         (with-open [rdr (io/reader body)]
+           (doseq [line (line-seq rdr)]
+             (if (not= 200 status)
+               (let [msg line]
+                 (logger/warn logger-tag "Unexpected response status" status "." msg)
+                 (on-error {:message (str "Anthropic response status: " status)}))
+               (when (str/starts-with? line "data: ")
+                 (let [data (subs line 6)]
+                   (when-let [message (raw-data->messages data)]
+                     (on-message-received message)))))))
+         (catch Exception e
+           (on-error {:exception e}))))
+     (fn [e]
+       (on-error {:exception e})))))

src/eca/llm_providers/openai.clj

@@ -18,10 +18,15 @@
              finish_reason (assoc :finish-reason finish_reason)))
          choices)))
 
-(defn completion! [{:keys [model messages temperature api-key]
+(defn ^:private ->message [{:keys [role behavior context]} user-prompt]
+  (format "%s\n%s\n%s\nThe user is asking: '%s'"
+          role behavior context user-prompt))
+
+(defn completion! [{:keys [model user-prompt context temperature api-key]
                     :or {temperature 1.0}}
                    {:keys [on-message-received on-error]}]
-  (let [body {:model model
+  (let [messages [{:role "user" :content (->message context user-prompt)}]
+        body {:model model
               :messages messages
               :temperature temperature
               :stream true}