Merge branch 'master' into veo-banana-budget

Author: Yetibot

src/yetibot/core/adapters/discord.clj

@@ -108,8 +108,8 @@
     (guild-channels)))
 
 (defn- generated-image-info [msg]
-  (when-let [[_ id ext] (re-matches #".*/generated-images/([^.]+)\.(png|gif|mp4)$" (str/trim msg))]
-    {:id id :ext ext}))
+  (when-let [[url id ext] (re-find #"https?://\S+?/generated-images/([^./\s]+)\.(png|gif|mp4)" msg)]
+    {:url url :id id :ext ext}))
 
 (def discord-max-message-length 2000)
 
@@ -119,13 +119,23 @@
 
 (defn- send-msg [{:keys [conn]} msg]
   (try
-    (if-let [{:keys [id ext]} (generated-image-info msg)]
-      (when-let [{:keys [data]} (get @images/image-store id)]
+    (if-let [{:keys [url id ext]} (generated-image-info msg)]
+      (if-let [{:keys [data]} (get @images/image-store id)]
         (let [bytes (.decode (Base64/getDecoder) ^String data)
-              stream (java.io.ByteArrayInputStream. bytes)]
-          @(messaging/create-message!
-            (:rest @conn) chat/*target*
-            :stream {:content stream :filename (str id "." ext)})))
+              stream (java.io.ByteArrayInputStream. bytes)
+              clean-msg (str/replace msg url "")]
+          (if (str/blank? clean-msg)
+            @(messaging/create-message!
+              (:rest @conn) chat/*target*
+              :stream {:content stream :filename (str id "." ext)})
+            @(messaging/create-message!
+              (:rest @conn) chat/*target*
+              :content clean-msg
+              :stream {:content stream :filename (str id "." ext)})))
+        (if (> (count msg) discord-max-message-length)
+          (doseq [chunk (chunk-message msg)]
+            @(messaging/create-message! (:rest @conn) chat/*target* :content chunk))
+          @(messaging/create-message! (:rest @conn) chat/*target* :content msg)))
       (if (> (count msg) discord-max-message-length)
         (doseq [chunk (chunk-message msg)]
           @(messaging/create-message! (:rest @conn) chat/*target* :content chunk))

src/yetibot/core/commands/agent.clj

@@ -1,10 +1,33 @@
 (ns yetibot.core.commands.veo
-  (:require [taoensso.timbre :refer [info error]]
+  (:require [clojure.string :as string]
+            [taoensso.timbre :refer [info error]]
             [yetibot.core.hooks :refer [cmd-hook]]
             [yetibot.core.util.image-input :as image-input]
             [yetibot.core.util.gemini :as gemini]
+            [yetibot.core.chat :as chat]
             [yetibot.core.webapp.routes.images :refer [store-image!]]))
 
+(defn redact
+  "Strip a leaked Gemini API key from an error message before it reaches chat."
+  [msg]
+  (some-> msg (string/replace #"key=[^\s&\"]+" "key=***")))
+
+(def model-presets
+  {"lite" {:model "veo-3.1-lite-generate-preview" :duration 4}
+   "fast" {:model "veo-3.1-fast-generate-preview" :duration 4}
+   "gigaveo" {:model "veo-3.1-generate-preview" :duration 8}
+   "preview" {:model "veo-3.1-generate-preview" :duration 8}
+   "better" {:model "veo-3.1-generate-preview" :duration 8}})
+
+(defn parse-model-and-prompt
+  [raw-prompt]
+  (let [words (string/split (string/trim raw-prompt) #"\s+" 2)
+        first-word (string/lower-case (or (first words) ""))
+        preset (get model-presets first-word)]
+    (if (and preset (> (count words) 1))
+      (assoc preset :prompt (second words))
+      {:prompt raw-prompt})))
+
 (defn veo-budget-cmd
   "veo budget # show monthly budget status"
   {:yb/cat #{:info}}
@@ -24,29 +47,60 @@
 
 (defn veo-cmd
   "veo <prompt> # generate a short AI video with Veo
+   gigaveo <prompt> # generate a high-quality 8-second video with flagship Veo 3.1 model
 
    Examples:
    veo a cat jumping
-   veo a robot dancing in times square
-   veo make @someone breakdance"
+   veo lite a cat jumping
+   veo gigaveo a cat jumping
+   gigaveo a cat jumping"
   {:yb/cat #{:img :gif}}
-  [{:keys [match chat-source]}]
+  [{:keys [match chat-source user cmd]}]
   (if (gemini/configured?)
     (try
-      (let [{:keys [prompt image-urls]} (image-input/extract-images match chat-source)]
-        (info "veo: generating video for:" prompt "with" (count image-urls) "input image(s)")
-        (let [video (gemini/generate-video prompt image-urls)
-              id (store-image! video)
-              url (format "%s/generated-images/%s.mp4" (gemini/yetibot-base-url) id)]
-          (info "veo: video generated, serving at" url)
-          {:result/value url
-           :result/data {:id id :prompt match :url url}}))
+      (let [{:keys [prompt image-urls]} (image-input/extract-images match chat-source)
+            preset (if (= cmd "gigaveo")
+                     (assoc (get model-presets "gigaveo") :prompt prompt)
+                     (let [parsed (parse-model-and-prompt prompt)]
+                       (when (:model parsed)
+                         parsed)))
+            final-prompt (if preset (:prompt preset) prompt)
+            model (if preset (:model preset) (gemini/veo-model))
+            duration (if preset (:duration preset) (gemini/veo-duration))
+            adapter chat/*adapter*
+            target chat/*target*
+            thread-ts chat/*thread-ts*
+            user-mention (when-let [user-id (:id user)] (str "<@" user-id ">"))]
+        (info "veo: starting async video generation for:" final-prompt
+              "model:" model "duration:" duration "with" (count image-urls) "input image(s)")
+        (future
+          (binding [chat/*adapter* adapter
+                    chat/*target* target
+                    chat/*thread-ts* thread-ts]
+            (try
+              (let [video (gemini/generate-video final-prompt image-urls model duration)
+                    id (store-image! video)
+                    url (format "%s/generated-images/%s.mp4" (gemini/yetibot-base-url) id)
+                    cost (gemini/calculate-video-cost model duration)
+                    cost-str (format " (Cost: $%.2f)" cost)
+                    msg (if user-mention (str user-mention ": " url cost-str) (str url cost-str))]
+                (info "veo: video generated, serving at" url "cost:" cost)
+                (chat/send-msg msg))
+              (catch Exception e
+                (error "veo: generation error in future:" (.getMessage e))
+                (let [err-msg (str "Video generation failed: " (redact (.getMessage e)))
+                      msg (if user-mention (str user-mention ": " err-msg) err-msg)]
+                  (chat/send-msg msg))))))
+        {:result/value (str "🎥 Bonzi Buddy start generating video for \"" final-prompt "\". This take some time (30s to 3m)...")})
       (catch Exception e
-        (error "veo: generation error:" (.getMessage e))
-        {:result/error (str "Video generation failed: " (.getMessage e))}))
+        (error "veo: initialization error:" (.getMessage e))
+        {:result/error (str "Video generation initialization failed: " (redact (.getMessage e)))}))
     {:result/error
      "Gemini API is not configured. Set `gemini.key` in config."}))
 
 (cmd-hook #"veo"
   #"budget" veo-budget-cmd
   #".+" veo-cmd)
+
+(cmd-hook #"gigaveo"
+  #".+" veo-cmd)

src/yetibot/core/commands/veo.clj

@@ -0,0 +1,29 @@
+(ns yetibot.core.db.agent-run
+  "In-flight `!agent` runs. A row exists only while a run is running; the run
+   deletes its own row on any terminal outcome (success/error/timeout). A row
+   left behind means the JVM was killed mid-run (a restart) — those are the runs
+   resumed on the next boot."
+  (:require [yetibot.core.db.util :as db.util]))
+
+(def schema
+  {:schema/table "agent_run"
+   :schema/specs (into [[:run-id :text "NOT NULL"]
+                        [:request :text "NOT NULL"]
+                        [:target :text]
+                        [:context-channel :text]
+                        [:status-id :text]
+                        [:adapter-uuid :text]
+                        [:mentions :text]
+                        [:on-discord :boolean "NOT NULL" "DEFAULT false"]
+                        [:attempts :integer "NOT NULL" "DEFAULT 1"]]
+                       (db.util/default-fields))})
+
+(def create (partial db.util/create (:schema/table schema)))
+
+(def query (partial db.util/query (:schema/table schema)))
+
+(def update-where (partial db.util/update-where (:schema/table schema)))
+
+(def delete (partial db.util/delete (:schema/table schema)))
+
+(def find-all (partial db.util/find-all (:schema/table schema)))

src/yetibot/core/db/agent_run.clj

@@ -102,7 +102,7 @@
    otherwise nil"
   ([body] (extract-command body config-prefix))
   ([body prefix]
-    (re-find (re-pattern (str "^\\" prefix "(.+)")) body)))
+    (re-find (re-pattern (str "(?s)^\\" prefix "(.+)")) body)))
 
 (defn embedded-cmds
   "Parse a string and only return a collection of any embedded commands instead

src/yetibot/core/util/command.clj

@@ -297,30 +297,47 @@
 
 (defn veo-model [] (or (-> config :veo :model) default-veo-model))
 
-(defn- veo-duration [] (long (or (parse-number (-> config :veo :duration)) 4)))
+(defn veo-duration [] (long (or (parse-number (-> config :veo :duration)) 4)))
 
-(defn- veo-cost-per-second []
+(defn- veo-cost-per-second-for-model [model]
   (or (parse-number (-> config :veo :cost-per-second))
       (cond
-        (string/includes? (veo-model) "lite") 0.05
-        (string/includes? (veo-model) "fast") 0.15
+        (string/includes? model "lite") 0.05
+        (string/includes? model "fast") 0.15
         :else 0.40)))
 
+(defn calculate-video-cost
+  "Calculate the estimated cost in USD of generating a video of the specified
+   duration using the given model."
+  [model duration]
+  (* duration (veo-cost-per-second-for-model model)))
+
+(defn- veo-cost-per-second [] (veo-cost-per-second-for-model (veo-model)))
+
+(defn- veo-cost-units-for-model [model duration]
+  (max 1 (long (Math/ceil (/ (* duration (veo-cost-per-second-for-model model))
+                             (cost-per-image))))))
+
 (defn- veo-cost-units
   "Express a Veo clip's dollar cost as a count of image-equivalents so it draws
    down the shared monthly budget proportionally."
   []
-  (max 1 (long (Math/ceil (/ (* (veo-duration) (veo-cost-per-second))
-                             (cost-per-image))))))
+  (veo-cost-units-for-model (veo-model) (veo-duration)))
 
 (def ^:private veo-poll-interval-ms 6000)
 (def ^:private veo-max-polls 50) ; ~5 min ceiling
 
+;; Cap connect + read time on every Veo HTTP call so a stalled Google API surfaces
+;; as an error instead of hanging the run forever — an otherwise silent failure
+;; where the user gets neither a video nor an error.
+(def ^:private veo-http-timeouts {:connection-timeout 10000 :socket-timeout 120000})
+
 (defn- veo-image-part
   "Fetch an image URL and return a Veo instance image (base64), or nil. Used for
    image-to-video — e.g. a mentioned Discord user's avatar becomes the opening frame."
   [image-url]
-  (let [resp (client/get image-url {:as :byte-array :throw-exceptions false})
+  (let [resp (client/get image-url (merge veo-http-timeouts
+                                          {:as :byte-array :throw-exceptions false}))
         mime (first (string/split (get-in resp [:headers "Content-Type"] "image/png") #";"))]
     (when (<= 200 (:status resp) 299)
       {:mimeType mime
@@ -329,14 +346,17 @@
 (defn- veo-start
   "Kick off a Veo generation; returns the long-running operation name.
    When `image` is provided, Veo conditions the video on it (image-to-video)."
-  [prompt image]
-  (let [url (format "%s/models/%s:predictLongRunning?key=%s" api-base (veo-model) (:key config))
+  [prompt image model duration]
+  (let [model (or model (veo-model))
+        duration (or duration (veo-duration))
+        url (format "%s/models/%s:predictLongRunning?key=%s" api-base model (:key config))
         body {:instances [(cond-> {:prompt prompt} image (assoc :image image))]
-              :parameters {:aspectRatio "16:9" :durationSeconds (veo-duration)}}
-        resp (client/post url {:content-type :json
-                               :body (json/write-str body)
-                               :as :json
-                               :throw-exceptions false})]
+              :parameters {:aspectRatio "16:9" :durationSeconds duration}}
+        resp (client/post url (merge veo-http-timeouts
+                                     {:content-type :json
+                                      :body (json/write-str body)
+                                      :as :json
+                                      :throw-exceptions false}))]
     (if (<= 200 (:status resp) 299)
       (get-in resp [:body :name])
       (let [msg (extract-api-error (:body resp))]
@@ -349,7 +369,8 @@
   [op-name]
   (loop [n 0]
     (let [body (:body (client/get (format "%s/%s?key=%s" api-base op-name (:key config))
-                                  {:as :json :throw-exceptions false}))]
+                                  (merge veo-http-timeouts
+                                         {:as :json :throw-exceptions false})))]
       (cond
         (:error body) (throw (ex-info (str "Veo generation failed: "
                                            (get-in body [:error :message]))
@@ -362,9 +383,10 @@
 (defn- veo-download
   "Download the generated mp4 and return it base64-encoded."
   [uri]
-  (let [resp (client/get uri {:headers {"x-goog-api-key" (:key config)}
-                              :as :byte-array
-                              :throw-exceptions false})]
+  (let [resp (client/get uri (merge veo-http-timeouts
+                                    {:headers {"x-goog-api-key" (:key config)}
+                                     :as :byte-array
+                                     :throw-exceptions false}))]
     (if (<= 200 (:status resp) 299)
       (.encodeToString (Base64/getEncoder) ^bytes (:body resp))
       (throw (ex-info (str "Veo video download failed: " (:status resp))
@@ -376,15 +398,18 @@
    Optional image-urls condition the video (image-to-video); the first is used.
    Returns {:data <base64 mp4> :mime-type \"video/mp4\"}."
   ([prompt] (generate-video prompt nil))
-  ([prompt image-urls]
+  ([prompt image-urls] (generate-video prompt image-urls nil nil))
+  ([prompt image-urls model duration]
    (check-budget!)
-   (let [op (veo-start prompt (some-> (first image-urls) veo-image-part))
+   (let [model (or model (veo-model))
+         duration (or duration (veo-duration))
+         op (veo-start prompt (some-> (first image-urls) veo-image-part) model duration)
          _ (info "veo: generation started" op)
          done (veo-poll op)
          uri (get-in done [:response :generateVideoResponse :generatedSamples 0 :video :uri])]
      (when (string/blank? uri)
        (throw (ex-info "No video was generated. Try a different prompt."
                        {:type :no-video-generated :response (:response done)})))
      (let [data (veo-download uri)]
-       (record-image-generated! (veo-cost-units))
+       (record-image-generated! (veo-cost-units-for-model model duration))
        {:data data :mime-type "video/mp4"}))))

src/yetibot/core/util/gemini.clj

@@ -7,9 +7,11 @@
   #"(https?://\S+\.(?:jpg|jpeg|png|gif|webp)(?:[?\#]\S*)?|https?://(?:cdn\.discordapp\.com|media\.discordapp\.net|i\.imgur\.com)/\S+)")
 
 (defn- discord-avatar-url [{:keys [id avatar]}]
-  (when (and id avatar)
-    (let [ext (if (str/starts-with? avatar "a_") "gif" "png")]
-      (format "https://cdn.discordapp.com/avatars/%s/%s.%s?size=256" id avatar ext))))
+  (cond
+    (= id "269292446041636866") "https://i.imgflip.com/4/9omh8s.jpg"
+    (and id avatar) (let [ext (if (str/starts-with? avatar "a_") "gif" "png")]
+                      (format "https://cdn.discordapp.com/avatars/%s/%s.%s?size=256" id avatar ext))
+    :else nil))
 
 (defn- replace-mentions [prompt mentions]
   (reduce (fn [p {:keys [id username]}]

src/yetibot/core/util/image_input.clj

@@ -18,7 +18,13 @@
                       *target* (:room chat-source)]
               (info "chat-source" chat-source)
               (let [user {:username "api"}
-                    res (or text (handle-unparsed-expr chat-source user command))]
+                    raw-res (or text (handle-unparsed-expr chat-source user command))
+                    res (if (map? raw-res)
+                          (cond
+                            (contains? raw-res :value) (:value raw-res)
+                            (contains? raw-res :error) (:error raw-res)
+                            :else raw-res)
+                          raw-res)]
                 (chat-data-structure res)
                 res))
             (str "invalid chat-source:" chat-source))))

src/yetibot/core/webapp/routes/api.clj

@@ -4,6 +4,7 @@
                         [yetibot.core.handler :as handler]
                         [yetibot.core.models.users :as users]
                         [yetibot.core.chat :as chat]
+                        [yetibot.core.webapp.routes.images :as images]
                         [midje.sweet :refer [fact facts anything => provided]]))
 
 (facts
@@ -62,4 +63,44 @@
   (provided (users/create-user "fake" {:id 999 :username "fake"}) => {:username "fake"}
             (chat/chat-source 456) => {:channel-id 456 :room "fake"}
             (handler/handle-raw anything anything anything anything anything) => "called handle-raw")))
+
+(facts
+ "about generated-image-info"
+ (fact
+  "returns nil for messages without generated image URLs"
+  (#'discord/generated-image-info "hello there!") => nil)
+ (fact
+  "extracts ID and extension when only URL is present"
+  (#'discord/generated-image-info "http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png")
+  => {:url "http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png"
+      :id "fc62974c-0c61-4be6-8241-d1f79cd1eac0"
+      :ext "png"})
+ (fact
+  "extracts ID and extension when URL is embedded in text"
+  (#'discord/generated-image-info "Check out the celebration: http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png ! Very cool!")
+  => {:url "http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png"
+      :id "fc62974c-0c61-4be6-8241-d1f79cd1eac0"
+      :ext "png"}))
+
+(facts
+ "about send-msg with generated images"
+ (fact
+  "sends message with attachment stream on discord and strips url"
+  (with-redefs [images/image-store (atom {"fc62974c-0c61-4be6-8241-d1f79cd1eac0" {:data "SGVsbG8gd29ybGQ="}})]
+    (binding [chat/*target* 456]
+      (#'discord/send-msg {:conn (atom {:rest :fake-rest})}
+                          "Check out the celebration: http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png ! Very cool!")))
+  => "created-message-result"
+  (provided (messaging/create-message! :fake-rest 456
+                                      :content "Check out the celebration:  ! Very cool!"
+                                      :stream anything) => (future "created-message-result")))
+ (fact
+  "sends message with attachment stream without content if text is blank"
+  (with-redefs [images/image-store (atom {"fc62974c-0c61-4be6-8241-d1f79cd1eac0" {:data "SGVsbG8gd29ybGQ="}})]
+    (binding [chat/*target* 456]
+      (#'discord/send-msg {:conn (atom {:rest :fake-rest})}
+                          "http://localhost:3003/generated-images/fc62974c-0c61-4be6-8241-d1f79cd1eac0.png")))
+  => "created-message-result"
+  (provided (messaging/create-message! :fake-rest 456
+                                      :stream anything) => (future "created-message-result"))))