Fix Divide by zero in chat auto-compact for zero-limit models

models.dev returns 0 for context/output limits on image-only models
(e.g. openai/chatgpt-image-latest). The previous guard in auto-compact?
treated 0 as truthy, so the percentage calculation divided by zero and
crashed the prompt flow.

- Normalize non-positive limits to nil at the eca.models ingestion layer
- Tighten auto-compact? to require a positive :context limit
- Add regression tests for auto-compact?

🤖 Generated with [eca](https://eca.dev)

Co-Authored-By: eca-agent <git@eca.dev>

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Bugfix: avoid `Divide by zero` crash in chat auto-compact when models.dev reports `0` for a model's context/output limits (e.g. `openai/chatgpt-image-latest`); such limits are now normalized to `nil` and `auto-compact?` skips models without a known positive context window.
+
 ## 0.130.1
 
 - Add configurable skill paths and recursive directory loading for configured rules, commands, and skills; local skills are also discovered from `.agents/skills`. #423

src/eca/features/chat/lifecycle.clj

@@ -19,9 +19,13 @@
              (not (get-in db [:chats chat-id :auto-compacting?])))
     (let [compact-threshold (or (get-in config [:agent agent-name :autoCompactPercentage])
                                 (get-in config [:autoCompactPercentage]))
-          {:keys [session-tokens limit]} (shared/usage-sumary chat-id full-model db)]
-      (when (and compact-threshold session-tokens (:context limit))
-        (let [current-percentage (* (/ session-tokens (:context limit)) 100)]
+          {:keys [session-tokens limit]} (shared/usage-sumary chat-id full-model db)
+          context-limit (:context limit)]
+      (when (and compact-threshold
+                 session-tokens
+                 (number? context-limit)
+                 (pos? context-limit))
+        (let [current-percentage (* (/ session-tokens context-limit) 100)]
           (>= current-percentage compact-threshold))))))
 
 (defn send-content! [{:keys [messenger chat-id parent-chat-id]} role content]

src/eca/models.clj

@@ -62,6 +62,14 @@
 
 (def ^:private one-million 1000000)
 
+(defn ^:private pos-num
+  "Return n when n is a positive number, otherwise nil. Used to drop
+   meaningless 0/non-positive limits coming from upstream catalogs (e.g.
+   models.dev returning 0 for image-only models like
+   `openai/chatgpt-image-latest`)."
+  [n]
+  (when (and (number? n) (pos? n)) n))
+
 (def ^:private models-with-web-search-support
   #{"openai/gpt-4.1"
     "openai/gpt-5.2"
@@ -101,9 +109,9 @@
                         ;; maybe fixed after web-search toolcall is implemented
                         :web-search (contains? models-with-web-search-support (str provider "/" model))
                         :tools (get model-config "tool_call")
-                        :max-output-tokens (get-in model-config ["limit" "output"])}
-                       :limit {:context (get-in model-config ["limit" "context"])
-                               :output (get-in model-config ["limit" "output"])}
+                        :max-output-tokens (pos-num (get-in model-config ["limit" "output"]))}
+                       :limit {:context (pos-num (get-in model-config ["limit" "context"]))
+                               :output (pos-num (get-in model-config ["limit" "output"]))}
                        :input-token-cost (some-> (get-in model-config ["cost" "input"]) float (/ one-million))
                        :output-token-cost (some-> (get-in model-config ["cost" "output"]) float (/ one-million))
                        :input-cache-creation-token-cost (some-> (get-in model-config ["cost" "cache_write"]) float (/ one-million))

test/eca/features/chat/lifecycle_test.clj

@@ -0,0 +1,67 @@
+(ns eca.features.chat.lifecycle-test
+  (:require
+   [clojure.test :refer [deftest is testing]]
+   [eca.features.chat.lifecycle :as lifecycle]))
+
+(set! *warn-on-reflection* true)
+
+(def ^:private chat-id "c1")
+(def ^:private agent-name :default)
+(def ^:private full-model "openai/test")
+(def ^:private config {:autoCompactPercentage 75})
+
+(defn- db-with [usage model-caps]
+  {:chats {chat-id {:usage usage}}
+   :models {full-model model-caps}})
+
+(deftest auto-compact?-does-not-crash-on-zero-or-missing-context-limit
+  (testing "zero context limit (e.g. models.dev returning 0 for image-only models) is treated as unknown and returns falsy"
+    (let [db (db-with {:last-input-tokens 100 :last-output-tokens 50}
+                      {:limit {:context 0 :output 0}})]
+      (is (not (lifecycle/auto-compact? chat-id agent-name full-model config db)))))
+
+  (testing "nil context limit returns falsy"
+    (let [db (db-with {:last-input-tokens 100 :last-output-tokens 50}
+                      {:limit {:context nil :output nil}})]
+      (is (not (lifecycle/auto-compact? chat-id agent-name full-model config db)))))
+
+  (testing "missing :limit map returns falsy"
+    (let [db (db-with {:last-input-tokens 100 :last-output-tokens 50}
+                      {})]
+      (is (not (lifecycle/auto-compact? chat-id agent-name full-model config db)))))
+
+  (testing "unknown model (no entry in :models) returns falsy"
+    (let [db {:chats {chat-id {:usage {:last-input-tokens 100 :last-output-tokens 50}}}}]
+      (is (not (lifecycle/auto-compact? chat-id agent-name full-model config db))))))
+
+(deftest auto-compact?-with-positive-context-limit
+  (testing "returns truthy when usage meets/exceeds the configured threshold"
+    (let [db (db-with {:last-input-tokens 800 :last-output-tokens 0}
+                      {:limit {:context 1000 :output 1000}})]
+      (is (lifecycle/auto-compact? chat-id agent-name full-model config db))))
+
+  (testing "returns false when usage is below the configured threshold"
+    (let [db (db-with {:last-input-tokens 100 :last-output-tokens 0}
+                      {:limit {:context 1000 :output 1000}})]
+      (is (false? (lifecycle/auto-compact? chat-id agent-name full-model config db)))))
+
+  (testing "respects per-agent autoCompactPercentage override"
+    (let [db (db-with {:last-input-tokens 500 :last-output-tokens 0}
+                      {:limit {:context 1000 :output 1000}})]
+      (is (lifecycle/auto-compact? chat-id agent-name full-model
+                                   {:agent {agent-name {:autoCompactPercentage 40}}
+                                    :autoCompactPercentage 99}
+                                   db)))))
+
+(deftest auto-compact?-respects-in-progress-flags
+  (testing "returns nil when chat is already compacting"
+    (let [db (-> (db-with {:last-input-tokens 800 :last-output-tokens 0}
+                          {:limit {:context 1000 :output 1000}})
+                 (assoc-in [:chats chat-id :compacting?] true))]
+      (is (nil? (lifecycle/auto-compact? chat-id agent-name full-model config db)))))
+
+  (testing "returns nil when chat is already auto-compacting"
+    (let [db (-> (db-with {:last-input-tokens 800 :last-output-tokens 0}
+                          {:limit {:context 1000 :output 1000}})
+                 (assoc-in [:chats chat-id :auto-compacting?] true))]
+      (is (nil? (lifecycle/auto-compact? chat-id agent-name full-model config db))))))