Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

BOT-1044 Convert links back to metabase:// format before sending to llm (#71125)

appleby33661d4b6a30
diff --git a/src/metabase/metabot/agent/core.clj b/src/metabase/metabot/agent/core.clj
index 8ae696eb2a0..607183eb50f 100644
--- a/src/metabase/metabot/agent/core.clj
+++ b/src/metabase/metabot/agent/core.clj
@@ -6,6 +6,7 @@
[metabase.analytics.prometheus :as prometheus]
[metabase.config.core :as config]
[metabase.metabot.agent.analytics :as agent-analytics]
+ [metabase.metabot.agent.links :as links]
[metabase.metabot.agent.memory :as memory]
[metabase.metabot.agent.messages :as messages]
[metabase.metabot.agent.profiles :as profiles]
@@ -141,13 +142,14 @@
[:sequential ::message])
(mr/def ::state
- "Agent state containing queries, charts, chart-configs, todos, and transforms."
+ "Agent state containing queries, charts, chart-configs, todos, transforms, and link-registry."
[:map
[:queries {:optional true} [:map-of [:or :string :keyword] :map]]
[:charts {:optional true} [:map-of [:or :string :keyword] :map]]
[:chart-configs {:optional true} [:map-of [:or :string :keyword] :map]]
[:todos {:optional true} [:sequential :map]]
- [:transforms {:optional true} [:map-of [:or :string :keyword] :map]]])
+ [:transforms {:optional true} [:map-of [:or :string :keyword] :map]]
+ [:link-registry {:optional true} [:map-of [:or :string :keyword] :string]]])
(mr/def ::context
"Context information for the agent."
@@ -195,16 +197,38 @@
:else :stop))
;;; Call LLM
+(defn- part->invert-links-key
+ "Return the key that might contain links that need to be inverted or nil if no such key exists."
+ [part]
+ (cond
+ (and (= (:type part) :text) (string? (:text part)))
+ :text
+ (and (= (:role part) :user) (string? (:content part)))
+ :content))
+
+(defn- invert-links
+ "Apply link inversion to all :text parts in a sequence of AISDK parts.
+ Also inverts :content in user-role parts (which contain resolved URLs from prior requests)."
+ [parts registry-map]
+ (if (empty? registry-map)
+ parts
+ (mapv (fn [part]
+ (let [links-key (part->invert-links-key part)]
+ (cond-> part
+ links-key (-> (update links-key links/invert-links registry-map)
+ (update links-key links/invert-slack-links registry-map)))))
+ parts)))
(defn- call-llm
"Call the LLM and stream processed parts.
Builds AISDK parts from memory and passes them to the adapter which converts
them to its native wire format."
- [memory context profile tools iteration tracking-opts]
+ [memory context profile tools iteration tracking-opts link-registry-atom]
(let [model (:model profile)
system-msg (messages/build-system-message context profile tools)
- input-parts (messages/build-message-history memory)
+ input-parts (-> (messages/build-message-history memory)
+ (invert-links @link-registry-atom))
llm-opts (cond-> {}
(:required-tool-call? profile) (assoc :tool-choice "required"))]
(when *debug-log*
@@ -215,7 +239,8 @@
:parts input-parts
:tools (vec tools)}))
(eduction (streaming/post-process-xf (get-in memory [:state :queries] {})
- (get-in memory [:state :charts] {}))
+ (get-in memory [:state :charts] {})
+ link-registry-atom)
(self/call-llm model (:content system-msg) input-parts tools tracking-opts llm-opts))))
;;; Memory management
@@ -348,7 +373,8 @@
(memory/load-queries-from-state seeded)
(memory/load-charts-from-state seeded)
(memory/load-transforms-from-state seeded)
- (memory/load-todos-from-state seeded))
+ (memory/load-todos-from-state seeded)
+ (memory/load-link-registry-from-state seeded))
memory-atom (atom memory)
tools (agent-tools/wrap-tools-with-state base-tools memory-atom metabot-id)]
(log/info "Starting agent" {:profile profile-id
@@ -403,10 +429,12 @@
(with-span :debug {:name :metabot.agent/loop-step
:iteration iteration}
(let [{:keys [profile tools context memory-atom tracking-opts]} agent
- max-iter (:max-iterations profile 10)
- tracking-opts (assoc tracking-opts :iteration iteration)
- parts-atom (atom [])
- llm-call (call-llm @memory-atom context profile tools iteration tracking-opts)
+ max-iter (:max-iterations profile 10)
+ tracking-opts (assoc tracking-opts :iteration iteration)
+ memory @memory-atom
+ parts-atom (atom [])
+ link-registry-atom (atom (get-in memory [:state :link-registry] {}))
+ llm-call (call-llm memory context profile tools iteration tracking-opts link-registry-atom)
xf (comp (accumulate-usage-xf usage-atom)
(u/tee-xf parts-atom))
;; We use `reduce` instead of `transduce` because rf is the outer reducing
@@ -415,6 +443,8 @@
;; entire agent loop, not after every iteration.
result' (reduce (xf rf) result llm-call)
parts @parts-atom]
+ ;; Sync link registry back to memory after streaming completes
+ (swap! memory-atom assoc-in [:state :link-registry] @link-registry-atom)
;; Capture response for debug log
(when *debug-log*
(debug-log! {:iteration iteration
diff --git a/src/metabase/metabot/agent/links.clj b/src/metabase/metabot/agent/links.clj
index 8fafa725634..2f8ec3546f0 100644
--- a/src/metabase/metabot/agent/links.clj
+++ b/src/metabase/metabot/agent/links.clj
@@ -5,6 +5,7 @@
[buddy.core.codecs :as codecs]
[clojure.string :as str]
[metabase.lib.core :as lib]
+ [metabase.system.core :as system]
[metabase.util.json :as json]
[metabase.util.log :as log]))
@@ -139,29 +140,116 @@
and replaces metabase:// URLs with proper Metabase URLs.
Non-metabase:// links are preserved unchanged.
+ `link-registry-atom` is an atom of {resolved-url original-metabase-uri}.
+ Every successful resolution is recorded so that resolved URLs can later be
+ inverted back to metabase:// URIs (see [[invert-links]]).
+
Returns the text with all resolvable links replaced."
- [text queries-state charts-state]
+ [text queries-state charts-state link-registry-atom]
(when (string? text)
(str/replace text link-pattern
(fn [[_ link-text url]]
(if (str/starts-with? url "metabase://")
(if-let [resolved (resolve-metabase-uri url queries-state charts-state)]
- (str "[" link-text "](" resolved ")")
+ (do
+ (swap! link-registry-atom assoc resolved url)
+ (str "[" link-text "](" resolved ")"))
(do
(log/warn "Failed to resolve link URL" {:url url})
link-text))
(str "[" link-text "](" url ")"))))))
+;;; Link Inversion
+
+(defn- invert-matched-links
+ "Replace resolved URLs with original metabase:// URIs using pattern matching.
+ `match->url` extracts the URL from a regex match.
+ `rebuild` reconstructs the link syntax given [match-groups original-uri]."
+ [text pattern match->url rebuild registry-map]
+ (if (or (not (string? text))
+ (empty? text)
+ (empty? registry-map))
+ text
+ (str/replace text pattern
+ (fn [match]
+ (if-let [original (get registry-map (match->url match))]
+ (rebuild match original)
+ (first match))))))
+
+(defn invert-links
+ "Replace resolved URLs with their original metabase:// URIs.
+
+ Only replaces URLs that appear inside `[text](url)` markdown syntax.
+ `registry-map` is a map of {resolved-url original-metabase-uri}.
+
+ Returns `text` unchanged if `registry-map` is empty or nil."
+ [text registry-map]
+ (invert-matched-links text
+ link-pattern
+ (fn [[_ _ url]] url)
+ (fn [[_ link-text _] original]
+ (str "[" link-text "](" original ")"))
+ registry-map))
+
+;;; Slack Link Processing
+
+(def slack-link-pattern
+ "Regex matching a complete Slack-format link <metabase://type/id|text>."
+ #"<(metabase://[^>|]+)(?:\|([^>]*))?>")
+
+(defn- resolve-slack-link
+ "Resolve a single Slack-format metabase:// link match. Returns the replacement string."
+ [queries charts link-registry-atom [_ url link-text]]
+ (if-let [resolved (resolve-metabase-uri url queries charts)]
+ (let [absolute-url (str (system/site-url) resolved)]
+ (swap! link-registry-atom assoc absolute-url url)
+ (if link-text
+ (str "<" absolute-url "|" link-text ">")
+ (str "<" absolute-url ">")))
+ (do
+ (log/warn "Failed to resolve Slack link URL" {:url url})
+ (or link-text url))))
+
+(defn resolve-slack-links
+ "Resolve all Slack-format metabase:// links in text.
+
+ `link-registry-atom` is an atom of {absolute-url original-metabase-uri}.
+ Every successful resolution is recorded so that resolved URLs can later
+ be inverted back to metabase:// URIs (see [[invert-slack-links]])."
+ [text queries charts link-registry-atom]
+ (str/replace text slack-link-pattern (partial resolve-slack-link queries charts link-registry-atom)))
+
+(def ^:private slack-url-link-pattern
+ "Regex matching a Slack-format link <url|text> with any HTTP(S) URL."
+ #"<(https?://[^>|]+)(?:\|([^>]*))?>")
+
+(defn invert-slack-links
+ "Replace resolved absolute URLs with their original metabase:// URIs in Slack-format links.
+
+ Only replaces URLs that appear inside `<url|text>` Slack link syntax.
+ `registry-map` is a map of {resolved-absolute-url original-metabase-uri}.
+
+ Returns `text` unchanged if `registry-map` is empty or nil."
+ [text registry-map]
+ (invert-matched-links text
+ slack-url-link-pattern
+ (fn [[_ url _]] url)
+ (fn [[_ _ link-text] original]
+ (if link-text
+ (str "<" original "|" link-text ">")
+ (str "<" original ">")))
+ registry-map))
+
(defn resolve-links-xf
"Transducer that resolves metabase:// links in text parts.
Takes queries-state and charts-state for link resolution.
For :text parts, resolves metabase:// links to proper URLs.
For other part types, passes through unchanged."
- [queries-state charts-state]
+ [queries-state charts-state link-registry-atom]
(map (fn [part]
(if (and (= (:type part) :text) (:text part))
- (update part :text resolve-links queries-state charts-state)
+ (update part :text resolve-links queries-state charts-state link-registry-atom)
part))))
;;; Part Processing (deprecated, use resolve-links-xf)
@@ -173,9 +261,9 @@
For other part types, returns unchanged.
Deprecated: Use resolve-links-xf transducer instead."
- [part queries-state charts-state]
+ [part queries-state charts-state link-registry-atom]
(if (and (= (:type part) :text) (:text part))
- (update part :text resolve-links queries-state charts-state)
+ (update part :text resolve-links queries-state charts-state link-registry-atom)
part))
(defn process-parts-links
@@ -183,5 +271,5 @@
Returns parts with all text links resolved.
Deprecated: Use resolve-links-xf transducer instead."
- [parts queries-state charts-state]
- (into [] (resolve-links-xf queries-state charts-state) parts))
+ [parts queries-state charts-state link-registry-atom]
+ (into [] (resolve-links-xf queries-state charts-state link-registry-atom) parts))
diff --git a/src/metabase/metabot/agent/markdown_link_buffer.clj b/src/metabase/metabot/agent/markdown_link_buffer.clj
index 6727a61a717..ff49186eeb4 100644
--- a/src/metabase/metabot/agent/markdown_link_buffer.clj
+++ b/src/metabase/metabot/agent/markdown_link_buffer.clj
@@ -8,7 +8,6 @@
(:require
[clojure.string :as str]
[metabase.metabot.agent.links :as links]
- [metabase.system.core :as system]
[metabase.util.log :as log]))
(set! *warn-on-reflection* true)
@@ -17,37 +16,17 @@
(def initial-state
"Initial parser state."
- {:buffer ""
- :queries {}
- :charts {}})
+ {:buffer ""
+ :queries {}
+ :charts {}
+ :link-registry-atom (atom {})})
(defn with-context
- "Update the queries and charts context in the state."
- [state queries charts]
- (assoc state :queries queries :charts charts))
-
-;;; Slack Link Resolution
-
-(def ^:private slack-link-pattern
- "Regex matching a complete Slack-format link <metabase://type/id|text>."
- #"<(metabase://[^>|]+)(?:\|([^>]*))?>")
-
-(defn- resolve-slack-link
- "Resolve a single Slack-format metabase:// link match. Returns the replacement string."
- [queries charts [_ url link-text]]
- (if-let [resolved (links/resolve-metabase-uri url queries charts)]
- (let [absolute-url (str (system/site-url) resolved)]
- (if link-text
- (str "<" absolute-url "|" link-text ">")
- (str "<" absolute-url ">")))
- (do
- (log/warn "Failed to resolve Slack link URL" {:url url})
- (or link-text url))))
-
-(defn- resolve-slack-links
- "Resolve all Slack-format metabase:// links in text."
- [text queries charts]
- (str/replace text slack-link-pattern (partial resolve-slack-link queries charts)))
+ "Update the queries, charts, and link-registry-atom context in the state."
+ ([state queries charts]
+ (assoc state :queries queries :charts charts))
+ ([state queries charts link-registry-atom]
+ (assoc state :queries queries :charts charts :link-registry-atom link-registry-atom)))
;;; Buffering Logic
@@ -75,7 +54,7 @@
(when idx
(let [suffix (subs text idx)]
;; Only buffer if there's no closing > (i.e., the link is incomplete)
- (when-not (re-find slack-link-pattern suffix)
+ (when-not (re-find links/slack-link-pattern suffix)
idx)))))
(defn- find-potential-link-start
@@ -96,8 +75,8 @@
[{:keys [buffer] :as state} chunk]
(let [text (str buffer chunk)
;; Resolve complete markdown links, then Slack-format links
- resolved (-> (links/resolve-links text (:queries state) (:charts state))
- (resolve-slack-links (:queries state) (:charts state)))
+ resolved (-> (links/resolve-links text (:queries state) (:charts state) (:link-registry-atom state))
+ (links/resolve-slack-links (:queries state) (:charts state) (:link-registry-atom state)))
;; Then check for incomplete link at the end
split-point (find-potential-link-start resolved)]
(if split-point
@@ -131,12 +110,14 @@
Parameters:
- initial-queries: Initial map of query-id to query data
- - initial-charts: Initial map of chart-id to chart data"
- [initial-queries initial-charts]
+ - initial-charts: Initial map of chart-id to chart data
+ - link-registry-atom: Atom of {resolved-url original-metabase-uri}"
+ [initial-queries initial-charts link-registry-atom]
(fn [rf]
(let [state (volatile! (with-context initial-state
(or initial-queries {})
- (or initial-charts {})))
+ (or initial-charts {})
+ link-registry-atom))
queries (volatile! (or initial-queries {}))
charts (volatile! (or initial-charts {}))]
(fn
diff --git a/src/metabase/metabot/agent/memory.clj b/src/metabase/metabot/agent/memory.clj
index 71248b04bb4..bc7b3b68133 100644
--- a/src/metabase/metabot/agent/memory.clj
+++ b/src/metabase/metabot/agent/memory.clj
@@ -17,7 +17,7 @@
{:input-messages messages
:steps-taken []
:context context
- :state (or state {:queries {} :charts {} :todos [] :transforms {}})}))
+ :state (or state {:queries {} :charts {} :todos [] :transforms {} :link-registry {}})}))
(defn add-step
"Add a completed agent step to memory.
@@ -170,3 +170,15 @@
(if-let [todos (:todos state)]
(set-todos memory todos)
memory))
+
+(defn load-link-registry-from-state
+ "Load link registry from incoming state into memory.
+ Ensures keys are strings since JSON round-tripping may keywordize them."
+ [memory state]
+ (if-let [link-registry (not-empty (:link-registry state))]
+ (assoc-in memory [:state :link-registry]
+ ;; We don't use `name` in case the key is a relative url fragment like `:question/123`.
+ (update-keys link-registry #(if (keyword? %)
+ (subs (str %) 1)
+ %)))
+ memory))
diff --git a/src/metabase/metabot/agent/streaming.clj b/src/metabase/metabot/agent/streaming.clj
index 1e2ea0c97a9..18edce858d9 100644
--- a/src/metabase/metabot/agent/streaming.clj
+++ b/src/metabase/metabot/agent/streaming.clj
@@ -166,9 +166,10 @@
Parameters:
- initial-queries: Initial map of query-id to query data
- - initial-charts: Initial map of chart-id to chart data"
- [initial-queries initial-charts]
+ - initial-charts: Initial map of chart-id to chart data
+ - link-registry-atom: Atom of {resolved-url original-metabase-uri}"
+ [initial-queries initial-charts link-registry-atom]
(comp
expand-data-parts-xf
expand-reactions-xf
- (markdown-link-buffer/resolve-xf initial-queries initial-charts)))
+ (markdown-link-buffer/resolve-xf initial-queries initial-charts link-registry-atom)))
diff --git a/test/metabase/metabot/agent/links_test.clj b/test/metabase/metabot/agent/links_test.clj
index dfb1a4fdf7b..fbdb805071c 100644
--- a/test/metabase/metabot/agent/links_test.clj
+++ b/test/metabase/metabot/agent/links_test.clj
@@ -2,235 +2,275 @@
(:require
[clojure.string :as str]
[clojure.test :refer :all]
- [metabase.metabot.agent.links :as links]))
+ [metabase.lib.core :as lib]
+ [metabase.lib.test-metadata :as meta]
+ [metabase.lib.test-util :as lib.tu]
+ [metabase.metabot.agent.links :as links]
+ [metabase.test :as mt]))
-(deftest resolve-metabase-uri-test
+;;; resolve-metabase-uri tests
+
+(deftest ^:parallel resolve-metabase-uri-query-links-test
(testing "resolves query links"
(let [query-id "abc-123"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {}
result (links/resolve-metabase-uri "metabase://query/abc-123" queries-state charts-state)]
(is (string? result))
- (is (str/starts-with? result "/question#"))))
+ (is (str/starts-with? result "/question#")))))
+(deftest ^:parallel resolve-metabase-uri-missing-query-test
(testing "returns nil for missing query"
(let [result (links/resolve-metabase-uri "metabase://query/missing" {} {})]
- (is (nil? result))))
+ (is (nil? result)))))
+(deftest ^:parallel resolve-metabase-uri-entity-links-test
(testing "resolves entity links"
(is (= "/model/123" (links/resolve-metabase-uri "metabase://model/123" {} {})))
(is (= "/metric/456" (links/resolve-metabase-uri "metabase://metric/456" {} {})))
(is (= "/dashboard/789" (links/resolve-metabase-uri "metabase://dashboard/789" {} {})))
(is (= "/question/101" (links/resolve-metabase-uri "metabase://question/101" {} {})))
(is (= "/admin/transforms/202" (links/resolve-metabase-uri "metabase://transform/202" {} {})))
- (is (= "/table/123" (links/resolve-metabase-uri "metabase://table/123" {} {}))))
+ (is (= "/table/123" (links/resolve-metabase-uri "metabase://table/123" {} {})))))
+(deftest ^:parallel resolve-metabase-uri-unknown-entity-type-test
(testing "returns nil for unknown entity types"
- (is (nil? (links/resolve-metabase-uri "metabase://unknown/123" {} {}))))
+ (is (nil? (links/resolve-metabase-uri "metabase://unknown/123" {} {})))))
+(deftest ^:parallel resolve-metabase-uri-non-metabase-uris-test
(testing "returns nil for non-metabase URIs"
(is (nil? (links/resolve-metabase-uri "https://example.com" {} {})))
- (is (nil? (links/resolve-metabase-uri "/question/123" {} {}))))
+ (is (nil? (links/resolve-metabase-uri "/question/123" {} {})))))
+(deftest ^:parallel resolve-metabase-uri-missing-entity-ids-test
(testing "returns nil for missing entity IDs"
(is (nil? (links/resolve-metabase-uri "metabase://model/" {} {})))
(is (nil? (links/resolve-metabase-uri "metabase://metric/" {} {})))
- (is (nil? (links/resolve-metabase-uri "metabase://query/" {} {}))))
+ (is (nil? (links/resolve-metabase-uri "metabase://query/" {} {})))))
+(deftest ^:parallel resolve-metabase-uri-chart-links-test
(testing "resolves chart links using chart state"
(let [query-id "query-abc"
chart-id "chart-123"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {chart-id {:query-id query-id :chart-type :bar}}
result (links/resolve-metabase-uri "metabase://chart/chart-123" queries-state charts-state)]
(is (string? result))
- (is (str/starts-with? result "/question#"))))
+ (is (str/starts-with? result "/question#")))))
+(deftest ^:parallel resolve-metabase-uri-chart-fallback-to-query-test
(testing "falls back to query when chart link uses query ID"
;; LLM sometimes uses metabase://chart/ when it should use metabase://query/
(let [query-id "qp_6a8c1d99-6f46-4ebb-9b7e-2fcad97a7f1c"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {}
result (links/resolve-metabase-uri (str "metabase://chart/" query-id) queries-state charts-state)]
(is (string? result))
(is (str/starts-with? result "/question#")))))
-(deftest resolve-links-test
+;;; resolve-links tests
+
+(deftest ^:parallel resolve-links-markdown-test
(testing "resolves metabase:// links in markdown"
(let [query-id "test-query"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {}
text "Check out [My Results](metabase://query/test-query) for details."
- result (links/resolve-links text queries-state charts-state)]
+ result (links/resolve-links text queries-state charts-state (atom {}))]
(is (str/includes? result "[My Results](/question#"))
- (is (not (str/includes? result "metabase://")))))
+ (is (not (str/includes? result "metabase://"))))))
+(deftest ^:parallel resolve-links-preserves-non-metabase-test
(testing "preserves non-metabase links"
(let [text "Visit [Google](https://google.com) for more."
- result (links/resolve-links text {} {})]
- (is (= text result))))
+ result (links/resolve-links text {} {} (atom {}))]
+ (is (= text result)))))
+(deftest ^:parallel resolve-links-multiple-test
(testing "handles multiple links"
(let [text "[Model](metabase://model/1) and [Metric](metabase://metric/2)"
- result (links/resolve-links text {} {})]
+ result (links/resolve-links text {} {} (atom {}))]
(is (str/includes? result "[Model](/model/1)"))
- (is (str/includes? result "[Metric](/metric/2)"))))
+ (is (str/includes? result "[Metric](/metric/2)")))))
+(deftest ^:parallel resolve-links-no-links-test
(testing "handles text without links"
(let [text "Just some plain text"
- result (links/resolve-links text {} {})]
+ result (links/resolve-links text {} {} (atom {}))]
(is (= text result)))))
-(deftest process-part-links-test
+;;; process-part-links tests
+
+(deftest ^:parallel process-part-links-text-parts-test
(testing "processes text parts"
(let [part {:type :text :text "[Link](metabase://model/123)"}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
(is (= :text (:type result)))
- (is (= "[Link](/model/123)" (:text result)))))
+ (is (= "[Link](/model/123)" (:text result))))))
+(deftest ^:parallel process-part-links-non-text-parts-test
(testing "leaves non-text parts unchanged"
(let [part {:type :tool-input :function "search" :arguments {:query "test"}}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
(is (= part result)))))
-(deftest process-parts-links-test
+;;; process-parts-links tests
+
+(deftest ^:parallel process-parts-links-test
(testing "processes all parts"
(let [parts [{:type :text :text "[A](metabase://model/1)"}
{:type :tool-input :function "search"}
{:type :text :text "[B](metabase://metric/2)"}]
- result (links/process-parts-links parts {} {})]
+ result (links/process-parts-links parts {} {} (atom {}))]
(is (= 3 (count result)))
(is (= "[A](/model/1)" (-> result first :text)))
(is (= {:type :tool-input :function "search"} (second result)))
(is (= "[B](/metric/2)" (-> result (nth 2) :text))))))
-(deftest resolve-links-xf-test
+;;; resolve-links-xf tests
+
+(deftest ^:parallel resolve-links-xf-processes-text-parts-test
(testing "transducer processes text parts"
(let [parts [{:type :text :text "[A](metabase://model/1)"}
{:type :tool-input :function "search"}
{:type :text :text "[B](metabase://metric/2)"}]
- result (into [] (links/resolve-links-xf {} {}) parts)]
+ result (into [] (links/resolve-links-xf {} {} (atom {})) parts)]
(is (= 3 (count result)))
(is (= "[A](/model/1)" (-> result first :text)))
(is (= {:type :tool-input :function "search"} (second result)))
- (is (= "[B](/metric/2)" (-> result (nth 2) :text)))))
+ (is (= "[B](/metric/2)" (-> result (nth 2) :text))))))
+(deftest ^:parallel resolve-links-xf-with-transduce-test
(testing "transducer works with transduce"
(let [query-id "q1"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
parts [{:type :text :text "[Query](metabase://query/q1)"}]
- result (transduce (links/resolve-links-xf queries-state {})
+ result (transduce (links/resolve-links-xf queries-state {} (atom {}))
conj
[]
parts)]
(is (= 1 (count result)))
- (is (str/starts-with? (-> result first :text) "[Query](/question#"))))
+ (is (str/starts-with? (-> result first :text) "[Query](/question#")))))
+(deftest ^:parallel resolve-links-xf-composes-test
(testing "transducer composes with other transducers"
(let [parts [{:type :text :text "[A](metabase://model/1)"}
{:type :text :text "[B](metabase://model/2)"}
{:type :tool-input :function "search"}]
result (into []
- (comp (links/resolve-links-xf {} {})
+ (comp (links/resolve-links-xf {} {} (atom {}))
(filter #(= :text (:type %))))
parts)]
(is (= 2 (count result)))
(is (= "[A](/model/1)" (-> result first :text)))
- (is (= "[B](/model/2)" (-> result second :text)))))
+ (is (= "[B](/model/2)" (-> result second :text))))))
+(deftest ^:parallel resolve-links-xf-nil-state-test
(testing "transducer handles nil state maps"
(let [parts [{:type :text :text "[Link](metabase://model/123)"}]
- result (into [] (links/resolve-links-xf nil nil) parts)]
+ result (into [] (links/resolve-links-xf nil nil (atom {})) parts)]
(is (= "[Link](/model/123)" (-> result first :text))))))
;;; Nil handling tests - important for robustness against LLM edge cases
-(deftest resolve-metabase-uri-nil-handling-test
+(deftest ^:parallel resolve-metabase-uri-nil-uri-test
(testing "handles nil URI gracefully"
- (is (nil? (links/resolve-metabase-uri nil {} {}))))
+ (is (nil? (links/resolve-metabase-uri nil {} {})))))
+(deftest ^:parallel resolve-metabase-uri-empty-string-test
(testing "handles empty string URI"
- (is (nil? (links/resolve-metabase-uri "" {} {}))))
+ (is (nil? (links/resolve-metabase-uri "" {} {})))))
+(deftest ^:parallel resolve-metabase-uri-nil-state-maps-test
(testing "handles nil queries-state and charts-state"
(is (= "/model/123" (links/resolve-metabase-uri "metabase://model/123" nil nil)))
(is (= "/metric/456" (links/resolve-metabase-uri "metabase://metric/456" nil nil)))))
-(deftest resolve-links-nil-handling-test
+(deftest ^:parallel resolve-links-nil-text-test
(testing "handles nil text gracefully"
- ;; Note: This test verifies the function doesn't throw on edge cases
- ;; The actual behavior may need adjustment based on requirements
- (let [result (links/resolve-links nil {} {})]
- (is (nil? result))))
+ (let [result (links/resolve-links nil {} {} (atom {}))]
+ (is (nil? result)))))
+(deftest ^:parallel resolve-links-text-without-links-test
(testing "handles text with nil URL in regex capture groups"
- ;; This tests the case where markdown regex captures nil
(let [text "Some text without links"
- result (links/resolve-links text {} {})]
- (is (= text result))))
+ result (links/resolve-links text {} {} (atom {}))]
+ (is (= text result)))))
+(deftest ^:parallel resolve-links-empty-text-test
(testing "handles empty text"
- (let [result (links/resolve-links "" {} {})]
- (is (= "" result))))
+ (let [result (links/resolve-links "" {} {} (atom {}))]
+ (is (= "" result)))))
+(deftest ^:parallel resolve-links-nil-state-maps-test
(testing "handles nil state maps"
(let [text "[Link](metabase://model/123)"
- result (links/resolve-links text nil nil)]
+ result (links/resolve-links text nil nil (atom {}))]
(is (str/includes? result "[Link](/model/123)")))))
-(deftest process-part-links-edge-cases-test
+;;; process-part-links edge cases
+
+(deftest ^:parallel process-part-links-nil-text-test
(testing "handles part with nil text"
(let [part {:type :text :text nil}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
(is (= :text (:type result)))
- (is (nil? (:text result)))))
+ (is (nil? (:text result))))))
+(deftest ^:parallel process-part-links-empty-text-test
(testing "handles part with empty text"
(let [part {:type :text :text ""}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
(is (= :text (:type result)))
- (is (= "" (:text result)))))
+ (is (= "" (:text result))))))
+(deftest ^:parallel process-part-links-missing-type-test
(testing "handles part without :type key"
(let [part {:text "[Link](metabase://model/1)"}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
;; Should return unchanged since :type is not :text
- (is (= part result))))
+ (is (= part result)))))
+(deftest ^:parallel process-part-links-tool-output-test
(testing "handles tool-output parts (should not process links)"
(let [part {:type :tool-output :id "test-123" :result {:data "test"}}
- result (links/process-part-links part {} {})]
+ result (links/process-part-links part {} {} (atom {}))]
(is (= part result)))))
-(deftest chart-link-resolution-test
+;;; chart-link-resolution tests
+
+(deftest ^:parallel chart-link-resolves-with-state-test
(testing "resolves chart links correctly with state"
(let [query-id "q-abc-123"
chart-id "chart-xyz-789"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {chart-id {:query-id query-id :chart-type :bar}}
result (links/resolve-metabase-uri (str "metabase://chart/" chart-id) queries-state charts-state)]
(is (string? result))
- (is (str/starts-with? result "/question#"))))
+ (is (str/starts-with? result "/question#")))))
+(deftest ^:parallel chart-link-nil-when-not-found-test
(testing "chart link returns nil when chart not found and no query fallback"
(let [result (links/resolve-metabase-uri "metabase://chart/nonexistent" {} {})]
- (is (nil? result))))
+ (is (nil? result)))))
+(deftest ^:parallel chart-link-falls-back-to-query-test
(testing "chart link falls back to query when chart-id matches query-id"
(let [query-id "shared-id-123"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
charts-state {}
result (links/resolve-metabase-uri (str "metabase://chart/" query-id) queries-state charts-state)]
(is (string? result))
- (is (str/starts-with? result "/question#"))))
+ (is (str/starts-with? result "/question#")))))
+(deftest ^:parallel chart-link-missing-query-in-chart-state-test
(testing "chart link resolution with missing query-id in chart state"
;; Chart exists but references a query that doesn't exist
(let [charts-state {"chart-1" {:query-id "missing-query" :chart-type :line}}
@@ -238,65 +278,322 @@
;; Should return nil since the underlying query can't be resolved
(is (nil? result)))))
-(deftest query-link-resolution-test
+;;; query-link-resolution tests
+
+(deftest ^:parallel query-link-valid-query-test
(testing "resolves query links with valid query in state"
(let [query-id "test-query-id"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
result (links/resolve-metabase-uri (str "metabase://query/" query-id) queries-state {})]
(is (string? result))
- (is (str/starts-with? result "/question#"))))
+ (is (str/starts-with? result "/question#")))))
+(deftest ^:parallel query-link-missing-query-test
(testing "returns nil for missing query"
- (is (nil? (links/resolve-metabase-uri "metabase://query/nonexistent" {} {}))))
+ (is (nil? (links/resolve-metabase-uri "metabase://query/nonexistent" {} {})))))
+(deftest ^:parallel query-link-complex-nested-structure-test
(testing "handles query with complex nested structure"
(let [query-id "complex-query"
- query {:database 1
- :type :query
- :query {:source-table 1
- :joins [{:fields :all :source-table 2}]
- :filter [:= [:field 1 nil] "test"]}}
+ query (-> (lib.tu/venues-query)
+ (lib/join (-> (lib/join-clause (meta/table-metadata :categories))
+ (lib/with-join-fields :all)))
+ (lib/filter (lib/= (meta/field-metadata :venues :name) "test")))
queries-state {query-id query}
result (links/resolve-metabase-uri (str "metabase://query/" query-id) queries-state {})]
(is (string? result))
(is (str/starts-with? result "/question#")))))
-(deftest multiple-links-in-text-test
+;;; multiple-links tests
+
+(deftest ^:parallel multiple-different-link-types-test
(testing "processes multiple different link types in same text"
(let [query-id "q1"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
text "See [Model](metabase://model/1), [Metric](metabase://metric/2), and [Query](metabase://query/q1)"
- result (links/resolve-links text queries-state {})]
+ result (links/resolve-links text queries-state {} (atom {}))]
(is (str/includes? result "[Model](/model/1)"))
(is (str/includes? result "[Metric](/metric/2)"))
- (is (str/includes? result "/question#"))))
+ (is (str/includes? result "/question#")))))
+(deftest ^:parallel preserves-text-between-links-test
(testing "preserves text between links"
(let [text "Start [A](metabase://model/1) middle [B](metabase://model/2) end"
- result (links/resolve-links text {} {})]
+ result (links/resolve-links text {} {} (atom {}))]
(is (str/includes? result "Start "))
(is (str/includes? result " middle "))
(is (str/includes? result " end")))))
-(deftest special-characters-in-links-test
+;;; special-characters tests
+
+(deftest ^:parallel link-text-with-special-characters-test
(testing "handles link text with special characters"
(let [text "[Link with (parens)](metabase://model/1)"
- result (links/resolve-links text {} {})]
+ result (links/resolve-links text {} {} (atom {}))]
;; Markdown parser should handle this - may or may not match depending on regex
- (is (string? result))))
+ (is (string? result)))))
+(deftest ^:parallel uuid-entity-ids-test
(testing "handles entity IDs that look like UUIDs"
(let [query-id "550e8400-e29b-41d4-a716-446655440000"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
result (links/resolve-metabase-uri (str "metabase://query/" query-id) queries-state {})]
- (is (string? result))))
+ (is (string? result)))))
+(deftest ^:parallel nano-id-entity-ids-test
(testing "handles nano-id style identifiers"
(let [query-id "puL95JSvym3k23W1UUuog"
- query {:database 1 :type :query :query {:source-table 1}}
+ query (lib.tu/venues-query)
queries-state {query-id query}
result (links/resolve-metabase-uri (str "metabase://query/" query-id) queries-state {})]
(is (string? result)))))
+
+;;; Link registry recording tests
+
+(deftest ^:parallel resolve-links-records-entity-links-in-registry-test
+ (testing "records resolved entity links in registry atom"
+ (let [registry (atom {})
+ text "[Model](metabase://model/123) and [Metric](metabase://metric/456)"
+ _result (links/resolve-links text {} {} registry)]
+ (is (= {"/model/123" "metabase://model/123"
+ "/metric/456" "metabase://metric/456"}
+ @registry)))))
+
+(deftest ^:parallel resolve-links-records-query-links-in-registry-test
+ (testing "records resolved query links in registry atom"
+ (let [registry (atom {})
+ query-id "q1"
+ queries-state {query-id (lib.tu/venues-query)}
+ result (links/resolve-links "[Results](metabase://query/q1)" queries-state {} registry)
+ resolved-url (second (re-find #"\[Results\]\((/question#[^)]+)\)" result))]
+ (is (= 1 (count @registry)))
+ (is (= "metabase://query/q1" (get @registry resolved-url))))))
+
+(deftest ^:parallel resolve-links-records-dashboard-table-transform-links-test
+ (testing "records dashboard, table, and transform links"
+ (let [registry (atom {})
+ text "[Dash](metabase://dashboard/10) [Tbl](metabase://table/20) [Tx](metabase://transform/30)"
+ _result (links/resolve-links text {} {} registry)]
+ (is (= {"/dashboard/10" "metabase://dashboard/10"
+ "/table/20" "metabase://table/20"
+ "/admin/transforms/30" "metabase://transform/30"}
+ @registry)))))
+
+(deftest ^:parallel resolve-links-does-not-record-failed-resolutions-test
+ (testing "does not record failed resolutions"
+ (let [registry (atom {})
+ text "[Missing](metabase://query/nonexistent)"
+ _result (links/resolve-links text {} {} registry)]
+ (is (empty? @registry)))))
+
+(deftest ^:parallel resolve-links-does-not-record-non-metabase-links-test
+ (testing "does not record non-metabase links"
+ (let [registry (atom {})
+ text "[Google](https://google.com)"
+ _result (links/resolve-links text {} {} registry)]
+ (is (empty? @registry)))))
+
+;;; invert-links tests
+
+(deftest ^:parallel invert-links-replaces-resolved-urls-test
+ (testing "replaces resolved URLs with original metabase URIs"
+ (let [registry {"/model/123" "metabase://model/123"
+ "/metric/456" "metabase://metric/456"}
+ text "[Model](/model/123) and [Metric](/metric/456)"]
+ (is (= "[Model](metabase://model/123) and [Metric](metabase://metric/456)"
+ (links/invert-links text registry))))))
+
+(deftest ^:parallel invert-links-unchanged-for-empty-registry-test
+ (testing "returns text unchanged for empty registry"
+ (let [text "some text with [Link](/model/123)"]
+ (is (= text (links/invert-links text {})))
+ (is (= text (links/invert-links text nil))))))
+
+(deftest ^:parallel invert-links-nil-input-test
+ (testing "returns non-string input unchanged"
+ (is (nil? (links/invert-links nil {"/a" "b"})))))
+
+(deftest ^:parallel invert-links-no-matching-entries-test
+ (testing "handles registry entries that don't match text"
+ (let [text "no links here"]
+ (is (= text
+ (links/invert-links text {"/model/999" "metabase://model/999"}))))))
+
+(deftest ^:parallel invert-links-base64-with-regex-special-chars-test
+ (testing "handles base64 URLs with regex-special characters"
+ (let [resolved "/question#eyJkYXRhc2V0X3F1ZXJ5Ijp7fX0="
+ original "metabase://query/q1"
+ registry {resolved original}
+ text (str "[Results](" resolved ")")]
+ (is (= "[Results](metabase://query/q1)"
+ (links/invert-links text registry))))))
+
+(deftest ^:parallel invert-links-only-replaces-inside-markdown-links-test
+ (testing "does not replace URLs that appear outside of markdown link syntax"
+ (let [registry {"/model/123" "metabase://model/123"}
+ text "Visit /model/123 or see [Model](/model/123) for details"]
+ (is (= "Visit /model/123 or see [Model](metabase://model/123) for details"
+ (links/invert-links text registry))))))
+
+;;; Round-trip tests
+
+(deftest ^:parallel round-trip-entity-links-test
+ (testing "round-trip: resolve then invert returns original text for entity links"
+ (let [original "[Model](metabase://model/123) and [Dashboard](metabase://dashboard/456)"
+ registry (atom {})
+ resolved (links/resolve-links original {} {} registry)
+ inverted (links/invert-links resolved @registry)]
+ (is (= original inverted)))))
+
+(deftest ^:parallel round-trip-query-links-test
+ (testing "round-trip: resolve then invert for query links"
+ (let [query-id "q1"
+ queries-state {query-id (lib.tu/venues-query)}
+ original "[Results](metabase://query/q1)"
+ registry (atom {})
+ resolved (links/resolve-links original queries-state {} registry)
+ inverted (links/invert-links resolved @registry)]
+ (is (= original inverted)))))
+
+(deftest ^:parallel round-trip-mixed-link-types-test
+ (testing "round-trip: mixed link types"
+ (let [query-id "q1"
+ queries-state {query-id (lib.tu/venues-query)}
+ original (str "See [Model](metabase://model/1), "
+ "[Query](metabase://query/q1), and "
+ "[Table](metabase://table/42)")
+ registry (atom {})
+ resolved (links/resolve-links original queries-state {} registry)
+ inverted (links/invert-links resolved @registry)]
+ (is (= original inverted)))))
+
+;;; Slack link resolution tests
+
+(deftest resolve-slack-links-entity-links-test
+ (testing "resolves Slack-format metabase:// entity links"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (is (= "<https://metabase.example.com/model/123|My Model>"
+ (links/resolve-slack-links "<metabase://model/123|My Model>" {} {} (atom {}))))
+ (is (= "<https://metabase.example.com/dashboard/456>"
+ (links/resolve-slack-links "<metabase://dashboard/456>" {} {} (atom {})))))))
+
+(deftest resolve-slack-links-query-links-test
+ (testing "resolves Slack-format metabase://query links"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [query (lib.tu/venues-query)
+ result (links/resolve-slack-links "<metabase://query/q1|Results>" {"q1" query} {} (atom {}))]
+ (is (str/starts-with? result "<https://metabase.example.com/question#"))
+ (is (str/ends-with? result "|Results>"))))))
+
+(deftest resolve-slack-links-multiple-test
+ (testing "resolves multiple Slack-format links"
+ (mt/with-temporary-setting-values [site-url "https://mb.test"]
+ (is (= "<https://mb.test/model/1|Model A> and <https://mb.test/metric/2|Metric B>"
+ (links/resolve-slack-links "<metabase://model/1|Model A> and <metabase://metric/2|Metric B>" {} {} (atom {})))))))
+
+(deftest ^:parallel resolve-slack-links-unresolvable-test
+ (testing "falls back to link text for unresolvable Slack link"
+ (is (= "My Query"
+ (links/resolve-slack-links "<metabase://query/unknown|My Query>" {} {} (atom {})))))
+ (testing "falls back to URL for unresolvable Slack link without text"
+ (is (= "metabase://query/unknown"
+ (links/resolve-slack-links "<metabase://query/unknown>" {} {} (atom {}))))))
+
+(deftest ^:parallel resolve-slack-links-no-links-test
+ (testing "passes through text without Slack links"
+ (is (= "plain text" (links/resolve-slack-links "plain text" {} {} (atom {}))))
+ (is (= "x < y" (links/resolve-slack-links "x < y" {} {} (atom {}))))))
+
+;;; Slack link registry recording tests
+
+(deftest resolve-slack-links-records-entity-links-in-registry-test
+ (testing "records resolved Slack entity links in registry atom"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [registry (atom {})
+ _result (links/resolve-slack-links "<metabase://model/123|My Model> and <metabase://metric/456>"
+ {} {} registry)]
+ (is (= {"https://metabase.example.com/model/123" "metabase://model/123"
+ "https://metabase.example.com/metric/456" "metabase://metric/456"}
+ @registry))))))
+
+(deftest resolve-slack-links-records-query-links-in-registry-test
+ (testing "records resolved Slack query links in registry atom"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [registry (atom {})
+ query (lib.tu/venues-query)
+ result (links/resolve-slack-links "<metabase://query/q1|Results>" {"q1" query} {} registry)
+ url (second (re-find #"<([^|>]+)" result))]
+ (is (= 1 (count @registry)))
+ (is (= "metabase://query/q1" (get @registry url)))))))
+
+(deftest ^:parallel resolve-slack-links-does-not-record-failed-resolutions-test
+ (testing "does not record failed Slack resolutions"
+ (let [registry (atom {})
+ _result (links/resolve-slack-links "<metabase://query/nonexistent|Missing>" {} {} registry)]
+ (is (empty? @registry)))))
+
+;;; invert-slack-links tests
+
+(deftest ^:parallel invert-slack-links-replaces-resolved-urls-test
+ (testing "replaces resolved absolute URLs with original metabase URIs"
+ (let [registry {"https://metabase.example.com/model/123" "metabase://model/123"
+ "https://metabase.example.com/metric/456" "metabase://metric/456"}
+ text "<https://metabase.example.com/model/123|Model> and <https://metabase.example.com/metric/456|Metric>"]
+ (is (= "<metabase://model/123|Model> and <metabase://metric/456|Metric>"
+ (links/invert-slack-links text registry))))))
+
+(deftest ^:parallel invert-slack-links-without-link-text-test
+ (testing "inverts Slack links that have no display text"
+ (let [registry {"https://metabase.example.com/dashboard/1" "metabase://dashboard/1"}
+ text "<https://metabase.example.com/dashboard/1>"]
+ (is (= "<metabase://dashboard/1>"
+ (links/invert-slack-links text registry))))))
+
+(deftest ^:parallel invert-slack-links-unchanged-for-empty-registry-test
+ (testing "returns text unchanged for empty registry"
+ (let [text "<https://metabase.example.com/model/123|Model>"]
+ (is (= text (links/invert-slack-links text {})))
+ (is (= text (links/invert-slack-links text nil))))))
+
+(deftest ^:parallel invert-slack-links-nil-input-test
+ (testing "returns non-string input unchanged"
+ (is (nil? (links/invert-slack-links nil {"https://a.com/b" "metabase://b"})))))
+
+(deftest ^:parallel invert-slack-links-no-matching-entries-test
+ (testing "handles registry entries that don't match text"
+ (let [text "no links here"]
+ (is (= text
+ (links/invert-slack-links text {"https://a.com/model/1" "metabase://model/1"}))))))
+
+;;; Slack round-trip tests
+
+(deftest round-trip-slack-entity-links-test
+ (testing "round-trip: resolve then invert returns original text for Slack entity links"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [original "<metabase://model/123|My Model> and <metabase://dashboard/456|Dash>"
+ registry (atom {})
+ resolved (links/resolve-slack-links original {} {} registry)
+ inverted (links/invert-slack-links resolved @registry)]
+ (is (= original inverted))))))
+
+(deftest round-trip-slack-query-links-test
+ (testing "round-trip: resolve then invert for Slack query links"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [query (lib.tu/venues-query)
+ original "<metabase://query/q1|Results>"
+ registry (atom {})
+ resolved (links/resolve-slack-links original {"q1" query} {} registry)
+ inverted (links/invert-slack-links resolved @registry)]
+ (is (= original inverted))))))
+
+(deftest round-trip-slack-no-text-links-test
+ (testing "round-trip: resolve then invert for Slack links without display text"
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (let [original "<metabase://dashboard/789>"
+ registry (atom {})
+ resolved (links/resolve-slack-links original {} {} registry)
+ inverted (links/invert-slack-links resolved @registry)]
+ (is (= original inverted))))))
diff --git a/test/metabase/metabot/agent/markdown_link_buffer_test.clj b/test/metabase/metabot/agent/markdown_link_buffer_test.clj
index ddcfb102f1b..f490d9edc59 100644
--- a/test/metabase/metabot/agent/markdown_link_buffer_test.clj
+++ b/test/metabase/metabot/agent/markdown_link_buffer_test.clj
@@ -1,8 +1,9 @@
(ns metabase.metabot.agent.markdown-link-buffer-test
(:require
[clojure.test :refer :all]
+ [metabase.lib.test-util :as lib.tu]
[metabase.metabot.agent.markdown-link-buffer :as mlb]
- [metabase.system.core :as system]))
+ [metabase.test :as mt]))
(defn- process
"Process text through a fresh state with given queries/charts context.
@@ -10,15 +11,24 @@
([text] (process text {} {}))
([text queries] (process text queries {}))
([text queries charts]
- (let [[state output] (mlb/step (mlb/with-context mlb/initial-state queries charts) text)]
+ (let [[state output] (mlb/step (mlb/with-context mlb/initial-state queries charts (atom {})) text)]
[output (mlb/flush-state state)])))
+(defn- process-with-registry
+ "Like `process` but returns [output flushed registry-map]."
+ ([text] (process-with-registry text {} {}))
+ ([text queries] (process-with-registry text queries {}))
+ ([text queries charts]
+ (let [registry (atom {})
+ [state output] (mlb/step (mlb/with-context mlb/initial-state queries charts registry) text)]
+ [output (mlb/flush-state state) @registry])))
+
(defn- process-chunks
"Process multiple chunks through state, returns [outputs flushed]."
([chunks] (process-chunks chunks {} {}))
([chunks queries] (process-chunks chunks queries {}))
([chunks queries charts]
- (loop [state (mlb/with-context mlb/initial-state queries charts)
+ (loop [state (mlb/with-context mlb/initial-state queries charts (atom {}))
[chunk & more] chunks
outputs []]
(if chunk
@@ -28,19 +38,19 @@
;;; State machine / buffering tests
-(deftest nested-bracket-handling-test
+(deftest ^:parallel nested-bracket-handling-test
(testing "does not drop characters when nested brackets appear"
(let [[output flushed] (process "[foo[")]
(is (= "[foo" output))
(is (= "[" flushed)))))
-(deftest basic-text-passthrough-test
+(deftest ^:parallel basic-text-passthrough-test
(testing "passes through plain text unchanged"
(let [[output flushed] (process "Hello world")]
(is (= "Hello world" output))
(is (= "" flushed)))))
-(deftest buffering-incomplete-link-test
+(deftest ^:parallel buffering-incomplete-link-test
(testing "buffers incomplete markdown link"
(let [[outputs flushed] (process-chunks ["Check [link" "](http://example.com)"])]
(is (= ["Check " "[link](http://example.com)"] outputs))
@@ -56,7 +66,7 @@
(is (= "Incomplete " output))
(is (= "[link" flushed)))))
-(deftest regular-url-passthrough-test
+(deftest ^:parallel regular-url-passthrough-test
(testing "passes through regular URLs unchanged"
(let [[output flushed] (process "[Google](https://google.com)")]
(is (= "[Google](https://google.com)" output))
@@ -66,9 +76,9 @@
(def resolved-link-re #"\[Results\]\(/question#[a-zA-ZZ0-9=]+\)")
-(deftest resolve-query-link-test
+(deftest ^:parallel resolve-query-link-test
(testing "resolves metabase://query links using queries-state"
- (let [query {:database 1 :type :query :query {:source-table 1}}
+ (let [query (lib.tu/venues-query)
[output flushed] (process "[Results](metabase://query/q-123)" {"q-123" query})]
(is (=? resolved-link-re output))
(is (not (re-find #"metabase://" output)))
@@ -80,14 +90,14 @@
(is (= "" flushed))))
(testing "incomplete chunks are also replaced well"
- (let [query {:database 1 :type :query :query {:source-table 1}}
+ (let [query (lib.tu/venues-query)
[output flushed] (process-chunks ["Your [Res" "ults](metabase://qu" "ery/q-123)"] {"q-123" query})]
(is (=? ["Your " "" resolved-link-re] output))
(is (= "" flushed)))))
-(deftest resolve-chart-link-test
+(deftest ^:parallel resolve-chart-link-test
(testing "resolves metabase://chart links using charts-state"
- (let [query {:database 1 :type :query :query {:source-table 1}}
+ (let [query (lib.tu/venues-query)
queries {"q-456" query}
charts {"c-789" {:query-id "q-456" :chart-type :bar}}
[output flushed] (process "[My Chart](metabase://chart/c-789)" queries charts)]
@@ -100,7 +110,7 @@
(is (= "Chart" output))
(is (= "" flushed)))))
-(deftest resolve-entity-link-test
+(deftest ^:parallel resolve-entity-link-test
(testing "resolves metabase://model links"
(let [[output flushed] (process "[My Model](metabase://model/123)")]
(is (= "[My Model](/model/123)" output))
@@ -121,16 +131,16 @@
(is (= "[Users Table](/table/42)" output))
(is (= "" flushed)))))
-(deftest resolve-link-split-across-chunks-test
+(deftest ^:parallel resolve-link-split-across-chunks-test
(testing "resolves metabase:// link split across multiple chunks"
- (let [query {:database 1 :type :query :query {:source-table 1}}
+ (let [query (lib.tu/venues-query)
[outputs flushed] (process-chunks ["Check [Results](metabase://" "query/split-query)"]
{"split-query" query})]
(is (= "Check " (first outputs)))
(is (re-find #"\[Results\]\(/question#" (second outputs)))
(is (= "" flushed)))))
-(deftest multiple-links-in-text-test
+(deftest ^:parallel multiple-links-in-text-test
(testing "resolves multiple links in same chunk"
(let [[output flushed] (process "[Model A](metabase://model/1) and [Model B](metabase://model/2)")]
(is (= "[Model A](/model/1) and [Model B](/model/2)" output))
@@ -144,18 +154,18 @@
;;; Slack link resolution tests
(deftest resolve-slack-link-test
- (testing "resolves Slack-format metabase:// links"
- (with-redefs [system/site-url (constantly "https://metabase.example.com")]
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (testing "resolves Slack-format metabase:// links"
(let [[output flushed] (process "<metabase://model/123|My Model>")]
(is (= "<https://metabase.example.com/model/123|My Model>" output))
- (is (= "" flushed)))))
+ (is (= "" flushed))))
- (testing "resolves Slack link without link text"
- (with-redefs [system/site-url (constantly "https://metabase.example.com")]
+ (testing "resolves Slack link without link text"
(let [[output flushed] (process "<metabase://dashboard/456>")]
(is (= "<https://metabase.example.com/dashboard/456>" output))
- (is (= "" flushed)))))
+ (is (= "" flushed))))))
+(deftest ^:parallel resolve-slack-link-unresolvable-test
(testing "falls back to link text for unresolvable Slack link"
(let [[output flushed] (process "<metabase://query/unknown|My Query>")]
(is (= "My Query" output))
@@ -163,35 +173,83 @@
(deftest slack-link-buffering-test
(testing "buffers incomplete Slack-format links"
- (with-redefs [system/site-url (constantly "https://metabase.example.com")]
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
(let [[outputs flushed] (process-chunks ["Check <metabase://mod" "el/123|My Model>"])]
(is (= "Check " (first outputs)))
(is (re-find #"metabase\.example\.com/model/123" (second outputs)))
- (is (= "" flushed)))))
+ (is (= "" flushed))))))
+(deftest ^:parallel slack-link-no-buffering-regular-angle-brackets-test
(testing "does NOT buffer regular < characters"
(let [[output flushed] (process "x < y and z > w")]
(is (= "x < y and z > w" output))
(is (= "" flushed)))))
(deftest mixed-link-formats-test
- (testing "resolves both markdown and Slack-format links in same text"
- (with-redefs [system/site-url (constantly "https://metabase.example.com")]
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (testing "resolves both markdown and Slack-format links in same text"
(let [[output flushed] (process "[Model](/model/1) and <metabase://dashboard/2|Dashboard>")]
(is (= "[Model](/model/1) and <https://metabase.example.com/dashboard/2|Dashboard>" output))
(is (= "" flushed))))))
+;;; Slack link registry recording tests
+
+(deftest resolve-slack-link-records-in-registry-test
+ (mt/with-temporary-setting-values [site-url "https://metabase.example.com"]
+ (testing "records resolved Slack links in registry"
+ (let [[_output _flushed registry] (process-with-registry "<metabase://model/123|My Model>")]
+ (is (= {"https://metabase.example.com/model/123" "metabase://model/123"}
+ registry))))
+
+ (testing "records multiple Slack links in registry"
+ (let [[_output _flushed registry] (process-with-registry
+ "<metabase://model/1|A> and <metabase://dashboard/2|B>")]
+ (is (= {"https://metabase.example.com/model/1" "metabase://model/1"
+ "https://metabase.example.com/dashboard/2" "metabase://dashboard/2"}
+ registry))))))
+
+(deftest ^:parallel resolve-slack-link-does-not-record-failed-in-registry-test
+ (testing "does not record failed Slack resolutions in registry"
+ (let [[_output _flushed registry] (process-with-registry "<metabase://query/unknown|Missing>")]
+ (is (empty? registry)))))
+
;;; with-context tests
-(deftest with-context-test
+(deftest ^:parallel resolve-xf-records-link-registry-test
+ (testing "resolve-xf records resolved links in link-registry-atom"
+ (let [registry (atom {})
+ parts [{:type :text :text "[Model](metabase://model/1)"}
+ {:type :text :text " and [Dash](metabase://dashboard/2)"}]
+ result (into [] (mlb/resolve-xf {} {} registry) parts)]
+ (is (= "[Model](/model/1)" (-> result first :text)))
+ (is (= " and [Dash](/dashboard/2)" (-> result second :text)))
+ (is (= {"/model/1" "metabase://model/1"
+ "/dashboard/2" "metabase://dashboard/2"}
+ @registry)))))
+
+(deftest ^:parallel resolve-xf-accumulates-queries-and-records-link-registry-test
+ (testing "resolve-xf accumulates queries and records query link in registry"
+ (let [registry (atom {})
+ query (lib.tu/venues-query)
+ parts [{:type :tool-output
+ :id "t1"
+ :result {:structured-output {:query-id "q1" :query query}}}
+ {:type :text :text "[Results](metabase://query/q1)"}]
+ result (into [] (mlb/resolve-xf {} {} registry) parts)]
+ (is (re-find #"\[Results\]\(/question#" (-> result second :text)))
+ (is (= 1 (count @registry)))
+ (is (= "metabase://query/q1" (first (vals @registry)))))))
+
+(deftest ^:parallel with-context-test
(testing "updates state for subsequent link resolution"
- (let [;; First, link cannot be resolved
- state1 (mlb/with-context mlb/initial-state {} {})
+ (let [registry (atom {})
+ ;; First, link cannot be resolved
+ state1 (mlb/with-context mlb/initial-state {} {} registry)
[state2 output1] (mlb/step state1 "[Results](metabase://query/new-query)")
_ (is (= "Results" output1))
;; Update state with the query
- query {:database 1 :type :query :query {:source-table 1}}
- state3 (mlb/with-context state2 {"new-query" query} {})
+ query (lib.tu/venues-query)
+ state3 (mlb/with-context state2 {"new-query" query} {} registry)
;; Now link can be resolved
[state4 output2] (mlb/step state3 " See [More](metabase://query/new-query)")]
(is (re-find #"\[More\]\(/question#" output2))
diff --git a/test/metabase/metabot/agent/memory_test.clj b/test/metabase/metabot/agent/memory_test.clj
index 2d55b401f3e..add9d0ab46f 100644
--- a/test/metabase/metabot/agent/memory_test.clj
+++ b/test/metabase/metabot/agent/memory_test.clj
@@ -15,7 +15,8 @@
(testing "initializes with default state when nil"
(let [messages [{:role :user :content "Hello"}]
mem (memory/initialize messages nil)]
- (is (= {:queries {} :charts {} :todos [] :transforms {}} (:state mem))))))
+ (is (= {:queries {} :charts {} :todos [] :transforms {} :link-registry {}}
+ (:state mem))))))
(deftest add-step-test
(testing "adds step to memory"
diff --git a/test/metabase/metabot/agent/streaming_test.clj b/test/metabase/metabot/agent/streaming_test.clj
index af97d6e73ed..93582caeb2f 100644
--- a/test/metabase/metabot/agent/streaming_test.clj
+++ b/test/metabase/metabot/agent/streaming_test.clj
@@ -240,13 +240,13 @@
(testing "resolves metabase:// links in text parts"
(let [query {:database 1 :type :query :query {:source-table 1}}
parts [{:type :text :text "[Results](metabase://query/q1)"}]
- result (into [] (streaming/post-process-xf {"q1" query} {}) parts)]
+ result (into [] (streaming/post-process-xf {"q1" query} {} (atom {})) parts)]
(is (= 1 (count result)))
(is (re-find #"\[Results\]\(/question#" (:text (first result))))))
(testing "passes through non-text parts unchanged"
(let [parts [{:type :tool-input :id "t1" :function "search"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
(is (= parts result))))
(testing "accumulates queries from tool-output structured-output"
@@ -255,13 +255,13 @@
:id "t1"
:result {:structured-output {:query-id "q1" :query query}}}
{:type :text :text "[Results](metabase://query/q1)"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
(is (= 2 (count result)))
(is (re-find #"\[Results\]\(/question#" (:text (second result))))))
(testing "flushes incomplete links at end"
(let [parts [{:type :text :text "Check [incomplete"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
;; Should have original part (with empty/partial text) + flushed part
(is (<= 1 (count result)))
(let [all-text (->> result (filter #(= :text (:type %))) (map :text) (apply str))]
@@ -269,7 +269,7 @@
(testing "resolves model/metric/dashboard links without state"
(let [parts [{:type :text :text "[Model](metabase://model/123)"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
(is (= "[Model](/model/123)" (:text (first result)))))))
(deftest post-process-xf-test
@@ -281,7 +281,7 @@
:reactions [{:type :metabot.reaction/redirect :url "/nav"}]
:data-parts [{:type :data :data-type "todo_list" :data []}]}}
{:type :text :text "[Link](metabase://query/q1)"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
;; Should have: tool-output, navigate_to data part, todo_list data part, resolved text
(is (= 4 (count result)))
(is (= :tool-output (:type (nth result 0))))
@@ -290,7 +290,7 @@
(is (re-find #"\[Link\]\(/question#" (:text (nth result 3))))))
(testing "works with empty parts"
- (let [result (into [] (streaming/post-process-xf {} {}) [])]
+ (let [result (into [] (streaming/post-process-xf {} {} (atom {})) [])]
(is (= [] result))))
(testing "preserves order: tool-output, reactions, data-parts, text"
@@ -299,7 +299,7 @@
:result {:reactions [{:type :metabot.reaction/redirect :url "/r"}]
:data-parts [{:type :data :data-type "dp"}]}}
{:type :text :text "text"}]
- result (into [] (streaming/post-process-xf {} {}) parts)]
+ result (into [] (streaming/post-process-xf {} {} (atom {})) parts)]
(is (= :tool-output (:type (nth result 0))))
(is (= "navigate_to" (:data-type (nth result 1))))
(is (= "dp" (:data-type (nth result 2))))