Skip to content

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

Deftool macro for Metabot tool APIs; tool API reorganization (#66614)

Noah Moss59154067f9e8
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/suggested_prompts.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/suggested_prompts.clj
index 9ac7e28bdf5..7cbfc2a9321 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/suggested_prompts.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/suggested_prompts.clj
@@ -2,7 +2,7 @@
(:require
[medley.core :as m]
[metabase-enterprise.metabot-v3.client :as metabot-v3.client]
- [metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.dummy-tools]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as metabot-v3.tools.entity-details]
[metabase-enterprise.metabot-v3.tools.util :as metabot-v3.tools.u]
[metabase.lib-be.core :as lib-be]
[toucan2.core :as t2]))
@@ -44,7 +44,7 @@
{metrics :metric, models :model}
(->> (for [[[card-type database-id] group-cards] (group-by (juxt :type :database_id) limited-cards)
detail (map (fn [detail card] (assoc detail ::origin card))
- (metabot-v3.dummy-tools/cards-details card-type database-id group-cards nil)
+ (metabot-v3.tools.entity-details/cards-details card-type database-id group-cards nil)
group-cards)]
detail)
(group-by :type))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
index 9ebb63715d0..35316695c44 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/table_utils.clj
@@ -120,6 +120,16 @@
:metrics []}))
all-tables))))))
+(defn get-tables
+ "Get information about the tables in a given database.
+
+ Returns a map with :structured-output containing :database and :tables info.
+ This is the handler for the /get-tables tool endpoint."
+ [{:keys [database-id]}]
+ {:structured-output
+ {:database (t2/select-one [:model/Database :id :name :description :engine] database-id)
+ :tables (database-tables database-id)}})
+
(defn similar?
"Check if two strings are similar using Levenshtein distance with a max distance of 4."
[left right]
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
index 45c3091c3b3..eae3eb37869 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/api.clj
@@ -4,17 +4,14 @@
[buddy.core.hash :as buddy-hash]
[buddy.sign.jwt :as jwt]
[clojure.set :as set]
- [malli.core :as mc]
- [malli.transform :as mtx]
- [metabase-enterprise.metabot-v3.config :as metabot-v3.config]
- [metabase-enterprise.metabot-v3.context :as metabot-v3.context]
- [metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.dummy-tools]
[metabase-enterprise.metabot-v3.reactions]
[metabase-enterprise.metabot-v3.settings :as metabot-v3.settings]
[metabase-enterprise.metabot-v3.table-utils :as table-utils]
[metabase-enterprise.metabot-v3.tools.create-dashboard-subscription
:as metabot-v3.tools.create-dashboard-subscription]
+ [metabase-enterprise.metabot-v3.tools.deftool :refer [deftool]]
[metabase-enterprise.metabot-v3.tools.dependencies :as metabot-v3.tools.dependencies]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as metabot-v3.tools.entity-details]
[metabase-enterprise.metabot-v3.tools.field-stats :as metabot-v3.tools.field-stats]
[metabase-enterprise.metabot-v3.tools.filters :as metabot-v3.tools.filters]
[metabase-enterprise.metabot-v3.tools.find-outliers :as metabot-v3.tools.find-outliers]
@@ -31,11 +28,9 @@
[metabase.lib.schema.temporal-bucketing :as lib.schema.temporal-bucketing]
[metabase.request.core :as request]
[metabase.util :as u]
- [metabase.util.i18n :as i18n]
[metabase.util.log :as log]
[metabase.util.malli.registry :as mr]
- [metabase.util.malli.schema :as ms]
- [toucan2.core :as t2]))
+ [metabase.util.malli.schema :as ms]))
(defn- decode-ai-service-token
[token]
@@ -46,6 +41,8 @@
(log/error e "Bad AI service token")
nil)))
+;;; ------------------------------------------------ Shared Schemas -------------------------------------------------
+
(mr/def ::bucket
(into [:enum {:error/message "Valid bucket"
:encode/tool-api-request keyword}]
@@ -183,14 +180,6 @@
"minute", "hour" "day" "week" "month" "quarter" "year" "day-of-week"]]]]
[:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-(mr/def ::query-metric-arguments
- [:and
- [:map
- [:metric_id :int]
- [:filters {:optional true} [:maybe [:sequential ::filter]]]
- [:group_by {:optional true} [:maybe [:sequential ::group-by]]]]
- [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-
(mr/def ::aggregation
[:and
[:map
@@ -208,37 +197,6 @@
[:bucket {:optional true} ::bucket]]
[:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-(mr/def ::query-model-arguments
- [:and
- [:map
- [:model_id :int]
- [:fields {:optional true} [:maybe [:sequential ::field]]]
- [:filters {:optional true} [:maybe [:sequential ::filter]]]
- [:aggregations {:optional true} [:maybe [:sequential ::aggregation]]]
- [:group_by {:optional true} [:maybe [:sequential ::group-by]]]
- [:order_by {:optional true} [:maybe [:sequential [:map
- [:field ::field]
- [:direction [:enum {:encode/tool-api-request keyword} "asc" "desc"]]]]]]
- [:limit {:optional true} [:maybe :int]]]
- [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-
-(mr/def ::query-datasource-arguments
- [:and
- [:map
- [:table_id {:optional true} :int]
- [:model_id {:optional true} :int]
- [:fields {:optional true} [:maybe [:sequential ::field]]]
- [:filters {:optional true} [:maybe [:sequential ::filter]]]
- [:aggregations {:optional true} [:maybe [:sequential ::aggregation]]]
- [:group_by {:optional true} [:maybe [:sequential ::group-by]]]
- [:order_by {:optional true} [:maybe [:sequential [:map
- [:field ::field]
- [:direction [:enum {:encode/tool-api-request keyword} "asc" "desc"]]]]]]
- [:limit {:optional true} [:maybe :int]]]
- [:fn {:error/message "Exactly one of table_id and model_id required"}
- #(= (count (select-keys % [:table_id :model_id])) 1)]
- [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-
(mr/def ::count
[:and
:int
@@ -278,17 +236,6 @@
[:latest {:optional true} [:maybe :string]]
[:values {:optional true} [:maybe ::field-values]]])
-(mr/def ::field-values-result
- [:or
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:field_id :string]
- [:statistics {:optional true} [:maybe ::statistics]]
- [:values {:optional true} [:maybe [:sequential :any]]]]]]
- [:map
- [:output :string]]])
-
(mr/def ::field-type
[:enum {:decode/tool-api-response #(when % (-> % name u/->snake_case_en))}
"boolean" "date" "datetime" "time" "number" "string"])
@@ -322,7 +269,69 @@
[:map
[:output :string]]])
-(mr/def ::tool-request [:map [:conversation_id ms/UUIDString]])
+(mr/def ::basic-metric
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:type [:= :metric]]
+ [:name :string]
+ [:description {:optional true} [:maybe :string]]
+ [:default_time_dimension_field_id {:optional true} [:maybe :string]]])
+
+(mr/def ::full-metric
+ [:merge
+ ::basic-metric
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:queryable_dimensions {:optional true} ::columns]
+ [:verified {:optional true} :boolean]]])
+
+(mr/def ::table-result
+ [:map
+ [:id :int]
+ [:type [:enum :model :table]]
+ [:name :string]
+ [:display_name :string]
+ [:database_id :int]
+ [:database_engine :keyword]
+ [:database_schema {:optional true} [:maybe :string]] ; Schema name, if applicable
+ [:fields ::columns]
+ [:related_tables {:optional true} [:sequential [:ref ::table-result]]]
+ [:related_by {:optional true} [:maybe :string]]
+ [:description {:optional true} [:maybe :string]]
+ [:metrics {:optional true} [:sequential ::basic-metric]]])
+
+(mr/def ::basic-transform
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]
+ [:type [:enum {:decode/tool-api-response name} "mbql" "native" "python"]]
+ [:description {:optional true} [:maybe :string]]
+ [:entity_id {:optional true} [:maybe :string]]
+ ;; :source keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
+ [:source ::metabot-v3.tools.transforms/transform-source]])
+
+(mr/def ::full-transform
+ [:merge
+ ::basic-transform
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:created_at ms/TemporalString]
+ [:updated_at ms/TemporalString]
+ ;; :target keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
+ [:target ::metabot-v3.tools.transforms/transform-target]]])
+
+(mr/def ::basic-snippet
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:name :string]
+ [:description {:optional true} [:maybe :string]]])
+
+(mr/def ::full-snippet
+ [:merge
+ ::basic-snippet
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:content :string]]])
+
+;;; ---------------------------------------------- Discovery & Search -----------------------------------------------
(mr/def ::answer-sources-arguments
[:and
@@ -337,6 +346,84 @@
:with_metric_default_temporal_breakout :with-default-temporal-breakout?
:with_metric_queryable_dimensions :with-queryable-dimensions?})}]])
+(mr/def ::answer-sources-result
+ [:or
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:map
+ [:metrics [:sequential ::full-metric]]
+ [:models [:sequential ::table-result]]]]]
+ [:map [:output :string]]])
+
+(deftool "/answer-sources"
+ "Return top level meta information about available information sources."
+ {:args-schema ::answer-sources-arguments
+ :args-optional? true
+ :result-schema ::answer-sources-result
+ :handler metabot-v3.tools.entity-details/answer-sources})
+
+(mr/def ::search-arguments
+ [:and
+ [:map
+ [:term_queries {:optional true} [:maybe [:sequential :string]]]
+ [:semantic_queries {:optional true} [:maybe [:sequential :string]]]
+ [:entity_types {:optional true} [:maybe [:sequential [:enum "table" "model" "question" "dashboard" "metric" "database" "transform"]]]]
+ [:database_id {:optional true} [:maybe :int]]
+ [:created_at {:optional true} [:maybe ms/NonBlankString]]
+ [:last_edited_at {:optional true} [:maybe ms/NonBlankString]]
+ [:search_native_query {:optional true, :default false} [:maybe :boolean]]
+ [:limit {:optional true, :default 50} [:and :int [:fn #(<= 1 % 100)]]]
+ [:weights {:optional true} [:map-of :keyword number?]]]
+ [:map {:encode/tool-api-request
+ #(update-keys % (comp keyword u/->kebab-case-en))}]])
+
+(mr/def ::search-result-item
+ "Unified schema for search result items."
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:id :int]
+ [:type [:enum :table :model :dashboard :question :metric :database :transform]]
+ [:name :string]
+ [:display_name {:optional true} [:maybe :string]]
+ [:description {:optional true} [:maybe :string]]
+ [:database_id {:optional true} [:maybe :int]]
+ [:database_schema {:optional true} [:maybe :string]]
+ [:verified {:optional true} [:maybe :boolean]]
+ [:updated_at {:optional true} [:maybe :string]]
+ [:created_at {:optional true} [:maybe :string]]
+ [:collection {:optional true} [:maybe [:map
+ [:name {:optional true} [:maybe :string]]
+ [:authority_level {:optional true} [:maybe :string]]
+ [:description {:optional true} [:maybe :string]]]]]])
+
+(mr/def ::search-result
+ [:or
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:map
+ [:data [:sequential ::search-result-item]]
+ [:total_count :int]]]]
+ [:map [:output :string]]])
+
+(deftool "/search"
+ "Enhanced search with term and semantic queries using Reciprocal Rank Fusion."
+ {:args-schema ::search-arguments
+ :args-optional? true
+ :result-schema ::search-result
+ :handler metabot-v3.tools.search/search-tool})
+
+;; TODO (Cam 10/28/25) -- fix this endpoint route to use kebab-case for consistency with the rest of our REST API
+#_{:clj-kondo/ignore [:metabase/validate-defendpoint-route-uses-kebab-case]}
+(deftool "/search_v2"
+ "Enhanced search with term and semantic queries using Reciprocal Rank Fusion. This is identical to /search, but
+ duplicated in order to add a new capability to AI service that indicates that Metabot can search transforms. The
+ /search endpoint is kept around for backward compatibility."
+ {:args-schema ::search-arguments
+ :args-optional? true
+ :result-schema ::search-result
+ :handler metabot-v3.tools.search/search-tool})
+
+;;; ----------------------------------------------------- Actions -----------------------------------------------------
+
(mr/def ::subscription-schedule
(let [days ["sunday" "monday" "tuesday" "wednesday" "thursday" "friday" "saturday"]]
[:and
@@ -368,6 +455,14 @@
[:schedule ::subscription-schedule]]
[:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+(deftool "/create-dashboard-subscription"
+ "Create a dashboard subscription."
+ {:args-schema ::create-dashboard-subscription-arguments
+ :result-schema [:map [:output :string]]
+ :handler metabot-v3.tools.create-dashboard-subscription/create-dashboard-subscription})
+
+;;; ---------------------------------------------------- Analytics ----------------------------------------------------
+
(mr/def ::field-values-arguments
[:and
[:map
@@ -377,47 +472,22 @@
[:limit {:optional true} [:maybe :int]]]
[:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-(mr/def ::filter-records-arguments
- [:and
- [:map
- [:data_source [:and
- [:or
- [:map
- [:query [:map [:database :int]]]
- [:query_id {:optional true} :string]]
- [:map [:report_id :int]]
- [:map [:table_id :string]]]
- [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]]]
- [:filters [:sequential ::filter]]]
- [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
-
-(mr/def ::basic-metric
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:id :int]
- [:type [:= :metric]]
- [:name :string]
- [:description {:optional true} [:maybe :string]]
- [:default_time_dimension_field_id {:optional true} [:maybe :string]]])
-
-(mr/def ::full-metric
- [:merge
- ::basic-metric
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:queryable_dimensions {:optional true} ::columns]
- [:verified {:optional true} :boolean]]])
-
-(mr/def ::find-metric-result
+(mr/def ::field-values-result
[:or
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:field_id :string]
+ [:statistics {:optional true} [:maybe ::statistics]]
+ [:values {:optional true} [:maybe [:sequential :any]]]]]]
[:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output [:map
- [:id :int]
- [:type [:= :metric]]
- [:name :string]
- [:description [:maybe :string]]
- [:default_time_dimension_field_id [:maybe ::column]]
- [:queryable_dimensions [:sequential ::column]]]]]
- [:map [:output :string]]])
+ [:output :string]]])
+
+(deftool "/field-values"
+ "Return statistics and/or values for a given field of a given entity."
+ {:args-schema ::field-values-arguments
+ :result-schema ::field-values-result
+ :handler metabot-v3.tools.field-stats/field-values})
(mr/def ::find-outliers-arguments
[:and
@@ -449,6 +519,12 @@
[:value [:or :int :double]]]]]]
[:map [:output :string]]])
+(deftool "/find-outliers"
+ "Find outliers in the values provided by a data source for a given column."
+ {:args-schema ::find-outliers-arguments
+ :result-schema ::find-outliers-result
+ :handler metabot-v3.tools.find-outliers/find-outliers})
+
(mr/def ::generate-insights-arguments
[:map
;; query should not be changed to kebab-case
@@ -459,6 +535,16 @@
[:map [:report_id :int]]
[:map [:query :map]]]]])
+(deftool "/generate-insights"
+ "Generate insights."
+ {:args-schema ::generate-insights-arguments
+ :result-schema [:map
+ [:output :string]
+ [:reactions [:sequential :metabot.reaction/redirect]]]
+ :handler metabot-v3.tools.generate-insights/generate-insights})
+
+;;; -------------------------------------------------- Entity Details -------------------------------------------------
+
(mr/def ::get-current-user-result
[:or
[:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
@@ -469,6 +555,17 @@
[:email_address :string]
[:glossary [:maybe [:map-of :string :string]]]]]]
[:map [:output :string]]])
+
+(deftool "/get-current-user"
+ "Get information about user that started the conversation."
+ {:result-schema ::get-current-user-result
+ :handler metabot-v3.tools.entity-details/get-current-user})
+
+(mr/def ::get-dashboard-details-arguments
+ [:and
+ [:map [:dashboard_id :int]]
+ [:map {:encode/tool-api-request #(set/rename-keys % {:dashboard_id :dashboard-id})}]])
+
(mr/def ::get-dashboard-details-result
[:or
[:map
@@ -481,6 +578,12 @@
[:verified {:optional true} :boolean]]]]
[:map [:output :string]]])
+(deftool "/get-dashboard-details"
+ "Get information about a given dashboard."
+ {:args-schema ::get-dashboard-details-arguments
+ :result-schema ::get-dashboard-details-result
+ :handler metabot-v3.tools.entity-details/get-dashboard-details})
+
(mr/def ::get-metric-details-arguments
[:and
[:map
@@ -500,6 +603,15 @@
[:structured_output ::full-metric]]
[:map [:output :string]]])
+(deftool "/get-metric-details"
+ "Get information about a given metric."
+ {:args-schema ::get-metric-details-arguments
+ :result-schema ::get-metric-details-result
+ :handler metabot-v3.tools.entity-details/get-metric-details})
+
+(mr/def ::get-query-details-arguments
+ [:map [:query :map]])
+
(mr/def ::get-query-details-result
[:or
[:map
@@ -512,6 +624,12 @@
[:result_columns ::columns]]]]
[:map [:output :string]]])
+(deftool "/get-query-details"
+ "Get information about a given query."
+ {:args-schema ::get-query-details-arguments
+ :result-schema ::get-query-details-result
+ :handler metabot-v3.tools.entity-details/get-query-details})
+
(mr/def ::get-report-details-arguments
[:and
[:map
@@ -537,12 +655,18 @@
[:verified {:optional true} :boolean]]]]
[:map [:output :string]]])
+(deftool "/get-report-details"
+ "Get information about a given report."
+ {:args-schema ::get-report-details-arguments
+ :result-schema ::get-report-details-result
+ :handler metabot-v3.tools.entity-details/get-report-details})
+
(mr/def ::get-document-details-arguments
[:and
[:map
- [:document_id :int]]
+ [:document_id :int]]
[:map {:encode/tool-api-request
- #(set/rename-keys % {:document_id :document-id})}]])
+ #(set/rename-keys % {:document_id :document-id})}]])
(mr/def ::get-document-details-result
[:or
@@ -555,34 +679,11 @@
[:document :string]]]]
[:map [:output :string]]])
-(mr/def ::get-tables-arguments
- [:and
- [:map
- [:database_id :int]]
- [:map {:encode/tool-api-request
- #(set/rename-keys % {:database_id :database-id})}]])
-
-(mr/def ::get-tables-result
- [:or
- [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:database [:map
- [:id :int]
- [:engine :string]
- [:name :string]
- [:description :string]]]
- [:tables [:sequential [:map
- [:id :int]
- [:name :string]
- [:description :string]
- [:columns [:sequential [:map
- [:id :int]
- [:name :string]
- [:description :string]
- [:type :string]]]]]]]]]]
- [:map [:output :string]]])
+(deftool "/get-document-details"
+ "Get information about a given document."
+ {:args-schema ::get-document-details-arguments
+ :result-schema ::get-document-details-result
+ :handler metabot-v3.tools.entity-details/get-document-details})
(mr/def ::get-table-details-arguments
[:and
@@ -605,46 +706,58 @@
:with_metrics :with-metrics?
:with_metric_default_temporal_breakout :with-default-temporal-breakout?})}]])
-(mr/def ::table-result
- [:map
- [:id :int]
- [:type [:enum :model :table]]
- [:name :string]
- [:display_name :string]
- [:database_id :int]
- [:database_engine :keyword]
- [:database_schema {:optional true} [:maybe :string]] ; Schema name, if applicable
- [:fields ::columns]
- [:related_tables {:optional true} [:sequential [:ref ::table-result]]]
- [:related_by {:optional true} [:maybe :string]]
- [:description {:optional true} [:maybe :string]]
- [:metrics {:optional true} [:sequential ::basic-metric]]])
-
(mr/def ::get-table-details-result
[:or
[:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
[:structured_output ::table-result]]
[:map [:output :string]]])
-(mr/def ::basic-transform
- [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:id :int]
- [:name :string]
- [:type [:enum {:decode/tool-api-response name} "mbql" "native" "python"]]
- [:description {:optional true} [:maybe :string]]
- [:entity_id {:optional true} [:maybe :string]]
- ;; :source keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
- [:source ::metabot-v3.tools.transforms/transform-source]])
+(deftool "/get-table-details"
+ "Get information about a given table or model."
+ {:args-schema ::get-table-details-arguments
+ :result-schema ::get-table-details-result
+ :handler metabot-v3.tools.entity-details/get-table-details})
-(mr/def ::full-transform
- [:merge
- ::basic-transform
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:created_at ms/TemporalString]
- [:updated_at ms/TemporalString]
- ;; :target keys are not snake_cased to match what the FE expects / provides in user_is_viewing context
- [:target ::metabot-v3.tools.transforms/transform-target]]])
+(mr/def ::get-tables-arguments
+ [:and
+ [:map
+ [:database_id :int]]
+ [:map {:encode/tool-api-request
+ #(set/rename-keys % {:database_id :database-id})}]])
+
+(mr/def ::get-tables-result
+ [:or
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:database [:map
+ [:id :int]
+ [:engine :string]
+ [:name :string]
+ [:description :string]]]
+ [:tables
+ [:sequential
+ [:map
+ [:id :int]
+ [:name :string]
+ [:description :string]
+ [:columns [:sequential
+ [:map
+ [:id :int]
+ [:name :string]
+ [:description :string]
+ [:type :string]]]]]]]]]]
+ [:map [:output :string]]])
+
+(deftool "/get-tables"
+ "Get information about the tables in a given database."
+ {:args-schema ::get-tables-arguments
+ :result-schema ::get-tables-result
+ :handler table-utils/get-tables})
+
+;;; ---------------------------------------------------- Transforms ---------------------------------------------------
(mr/def ::get-transforms-result
[:or
@@ -653,6 +766,11 @@
[:structured_output [:sequential ::basic-transform]]]
[:map [:output :string]]])
+(deftool "/get-transforms"
+ "Get a list of all known transforms."
+ {:result-schema ::get-transforms-result
+ :handler metabot-v3.tools.transforms/get-transforms})
+
(mr/def ::get-transform-details-arguments
[:and
[:map
@@ -666,6 +784,12 @@
[:structured_output [:sequential ::full-transform]]]
[:map [:output :string]]])
+(deftool "/get-transform-details"
+ "Get information about a transform."
+ {:args-schema ::get-transform-details-arguments
+ :result-schema ::get-transform-details-result
+ :handler metabot-v3.tools.transforms/get-transform-details})
+
(mr/def ::get-transform-python-library-details-arguments
[:and
[:map
@@ -683,481 +807,11 @@
[:updated_at ms/TemporalString]]]]
[:map [:output :string]]])
-(mr/def ::answer-sources-result
- [:or
- [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output [:map
- [:metrics [:sequential ::full-metric]]
- [:models [:sequential ::table-result]]]]]
- [:map [:output :string]]])
-
-(mr/def ::basic-snippet
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:id :int]
- [:name :string]
- [:description {:optional true} [:maybe :string]]])
-
-(mr/def ::full-snippet
- [:merge
- ::basic-snippet
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:content :string]]])
-
-(mr/def ::get-snippets-result
- "Schema for SQL snippet list results"
- [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output [:sequential ::basic-snippet]]])
-
-(mr/def ::get-snippet-details-arguments
- [:and
- [:map
- [:snippet_id :int]]
- [:map {:encode/tool-api-request
- #(set/rename-keys % {:snippet_id :snippet-id})}]])
-
-(mr/def ::get-snippet-details-result
- "Schema for SQL snippet detail results"
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output ::full-snippet]])
-
-(api.macros/defendpoint :post "/answer-sources" :- [:merge ::answer-sources-result ::tool-request]
- "Return top level meta information about available information sources."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments {:optional true} ::answer-sources-arguments]]
- ::tool-request]
- {:keys [metabot-v3/metabot-id]}]
- (metabot-v3.context/log (assoc body :api :answer-sources) :llm.log/llm->be)
- (if-let [normalized-metabot-id (metabot-v3.config/normalize-metabot-id metabot-id)]
- (let [options (mc/encode ::answer-sources-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::answer-sources-result
- (metabot-v3.dummy-tools/answer-sources normalized-metabot-id options)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
- (throw (ex-info (i18n/tru "Invalid metabot_id {0}" metabot-id)
- {:metabot_id metabot-id, :status-code 400}))))
-
-(api.macros/defendpoint :post "/create-dashboard-subscription" :- [:merge
- [:map [:output :string]]
- ::tool-request]
- "Create a dashboard subscription."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::create-dashboard-subscription-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :create-dashboard-subscription) :llm.log/llm->be)
- (let [arguments (mc/encode ::create-dashboard-subscription-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (metabot-v3.tools.create-dashboard-subscription/create-dashboard-subscription arguments)
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/field-values" :- [:merge ::field-values-result ::tool-request]
- "Return statistics and/or values for a given field of a given entity."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::field-values-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :field-values) :llm.log/llm->be)
- (let [arguments (mc/encode ::field-values-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::field-values-result
- (metabot-v3.tools.field-stats/field-values arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/filter-records" :- [:merge ::filtering-result ::tool-request]
- "Construct a query from a metric."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::filter-records-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :filter-records) :llm.log/llm->be)
- (let [arguments (mc/encode ::filter-records-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::filtering-result
- (metabot-v3.tools.filters/filter-records arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/find-outliers" :- [:merge ::find-outliers-result ::tool-request]
- "Find outliers in the values provided by a data source for a given column."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::find-outliers-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :find-outliers) :llm.log/llm->be)
- (let [arguments (mc/encode ::find-outliers-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::find-outliers-result
- (metabot-v3.tools.find-outliers/find-outliers arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/generate-insights" :- [:merge
- [:map
- [:output :string]
- [:reactions [:sequential :metabot.reaction/redirect]]]
- ::tool-request]
- "Generate insights."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::generate-insights-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :generate-insights) :llm.log/llm->be)
- (let [arguments (mc/encode ::generate-insights-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (metabot-v3.tools.generate-insights/generate-insights arguments)
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-current-user" :- [:merge ::get-current-user-result ::tool-request]
- "Get information about user that started the conversation."
- [_route-params
- _query-params
- {:keys [conversation_id] :as body} :- ::tool-request]
- (metabot-v3.context/log (assoc body :api :get-current-user) :llm.log/llm->be)
- (doto (-> (mc/decode ::get-current-user-result
- (metabot-v3.dummy-tools/get-current-user)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
-
-(api.macros/defendpoint :post "/get-dashboard-details" :- [:merge ::get-dashboard-details-result ::tool-request]
- "Get information about a given dashboard."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments [:map [:dashboard_id :int]]]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-dashboard-details) :llm.log/llm->be)
- (doto (-> (mc/decode ::get-dashboard-details-result
- (-> arguments
- (update-keys metabot-v3.u/safe->kebab-case-en)
- metabot-v3.dummy-tools/get-dashboard-details)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
-
-(api.macros/defendpoint :post "/get-metric-details" :- [:merge ::get-metric-details-result ::tool-request]
- "Get information about a given metric."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-metric-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-metric-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-metric-details-arguments arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::get-metric-details-result
- (metabot-v3.dummy-tools/get-metric-details arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-query-details" :- [:merge ::get-query-details-result ::tool-request]
- "Get information about a given query."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments [:map [:query :map]]]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-query-details) :llm.log/llm->be)
- (doto (-> (mc/decode ::get-query-details-result
- (metabot-v3.dummy-tools/get-query-details arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
-
-(api.macros/defendpoint :post "/get-report-details" :- [:merge ::get-report-details-result ::tool-request]
- "Get information about a given report."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-report-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-report-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-report-details-arguments arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::get-report-details-result
- (metabot-v3.dummy-tools/get-report-details arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-document-details" :- [:merge ::get-document-details-result ::tool-request]
- "Get information about a given report."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-document-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-document-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-document-details-arguments arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::get-document-details-result
- (metabot-v3.dummy-tools/get-document-details arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-table-details" :- [:merge ::get-table-details-result ::tool-request]
- "Get information about a given table or model."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-table-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-table-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-table-details-arguments arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::get-table-details-result
- (metabot-v3.dummy-tools/get-table-details arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-tables" :- [:merge ::get-tables-result ::tool-request]
- "Get information about the tables in a given database."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-tables-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-tables) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-tables-arguments arguments (mtx/transformer {:name :tool-api-request}))
- database-id (:database-id arguments)]
- (doto (-> (mc/decode ::get-tables-result
- {:structured-output {:database (t2/select-one [:model/Database :id :name :description :engine] database-id)
- :tables (table-utils/database-tables database-id)}}
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-transforms" :- [:merge ::get-transforms-result ::tool-request]
- "Get a list of all known transforms."
- [_route-params
- _query-params
- {:keys [conversation_id] :as body} :- ::tool-request]
- (metabot-v3.context/log (assoc body :api :get-transforms) :llm.log/llm->be)
- (doto (-> (mc/decode ::get-transforms-result
- (metabot-v3.tools.transforms/get-transforms)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
-
-(api.macros/defendpoint :post "/get-transform-details" :- [:merge ::get-transform-details-result ::tool-request]
- "Get information about a transform."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-transform-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-transform-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-transform-details-arguments arguments (mtx/transformer {:name :tool-api-request}))
- transform-id (:transform-id arguments)]
- (doto (-> (mc/decode ::get-transform-details-result
- (metabot-v3.tools.transforms/get-transform-details transform-id)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/get-transform-python-library-details" :- [:merge
- ::get-transform-python-library-details-result
- ::tool-request]
+(deftool "/get-transform-python-library-details"
"Get information about a Python library by path."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments
- ::get-transform-python-library-details-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :get-transform-python-library-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-transform-python-library-details-arguments
- arguments (mtx/transformer {:name :tool-api-request}))
- path (:path arguments)]
- (doto (-> (mc/decode ::get-transform-python-library-details-result
- (metabot-v3.tools.transforms/get-transform-python-library-details path)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/query-metric" :- [:merge ::filtering-result ::tool-request]
- "Construct a query from a metric."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::query-metric-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :query-metric) :llm.log/llm->be)
- (let [arguments (mc/encode ::query-metric-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::filtering-result
- (metabot-v3.tools.filters/query-metric arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(api.macros/defendpoint :post "/query-model" :- [:merge ::filtering-result ::tool-request]
- "Construct a query from a model."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::query-model-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :query-model) :llm.log/llm->be)
- (let [arguments (mc/encode ::query-model-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::filtering-result
- (metabot-v3.tools.filters/query-model arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-;; TODO tsplude - drop the `/query-model` endpoint and filter logic in favor of this
-(api.macros/defendpoint :post "/query-datasource" :- [:merge ::filtering-result ::tool-request]
- "Construct a query from a model or table data source."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::query-datasource-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :query-datasource) :llm.log/llm->be)
- (let [arguments (mc/encode ::query-datasource-arguments
- arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::filtering-result
- (metabot-v3.tools.filters/query-datasource arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
-
-(mr/def ::search-arguments
- [:and
- [:map
- [:term_queries {:optional true} [:maybe [:sequential :string]]]
- [:semantic_queries {:optional true} [:maybe [:sequential :string]]]
- [:entity_types {:optional true} [:maybe [:sequential [:enum "table" "model" "question" "dashboard" "metric" "database" "transform"]]]]
- [:database_id {:optional true} [:maybe :int]]
- [:created_at {:optional true} [:maybe ms/NonBlankString]]
- [:last_edited_at {:optional true} [:maybe ms/NonBlankString]]
- [:search_native_query {:optional true, :default false} [:maybe :boolean]]
- [:limit {:optional true, :default 50} [:and :int [:fn #(<= 1 % 100)]]]
- [:weights {:optional true} [:map-of :keyword number?]]]
- [:map {:encode/tool-api-request
- #(update-keys % (comp keyword u/->kebab-case-en))}]])
-
-(mr/def ::search-result-item
- "Unified schema for search result items."
- [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:id :int]
- [:type [:enum :table :model :dashboard :question :metric :database :transform]]
- [:name :string]
- [:display_name {:optional true} [:maybe :string]]
- [:description {:optional true} [:maybe :string]]
- [:database_id {:optional true} [:maybe :int]]
- [:database_schema {:optional true} [:maybe :string]]
- [:verified {:optional true} [:maybe :boolean]]
- [:updated_at {:optional true} [:maybe :string]]
- [:created_at {:optional true} [:maybe :string]]
- [:collection {:optional true} [:maybe [:map
- [:name {:optional true} [:maybe :string]]
- [:authority_level {:optional true} [:maybe :string]]
- [:description {:optional true} [:maybe :string]]]]]])
-
-(mr/def ::search-result
- [:or
- [:map
- {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
- [:structured_output [:map
- [:data [:sequential ::search-result-item]]
- [:total_count :int]]]]
- [:map [:output :string]]])
-
-(defn- search
- "Shared handler for the /search and /search_v2 endpoints."
- [arguments conversation_id request]
- (try
- (let [options (mc/encode ::search-arguments
- arguments (mtx/transformer {:name :tool-api-request}))
- metabot-id (:metabot-v3/metabot-id request)
- results (metabot-v3.tools.search/search
- (assoc options :metabot-id metabot-id))
- response-data {:data results
- :total_count (count results)}]
- (doto (-> (mc/decode ::search-result
- {:structured_output response-data}
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
- (catch Exception e
- (log/error e "Error in search")
- (doto (-> {:output (str "Search failed: " (or (ex-message e) "Unknown error"))}
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))))
-
-(api.macros/defendpoint :post "/search" :- [:merge ::search-result ::tool-request]
- "Enhanced search with term and semantic queries using Reciprocal Rank Fusion."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments {:optional true} ::search-arguments]]
- ::tool-request]
- request]
- (metabot-v3.context/log (assoc body :api :search) :llm.log/llm->be)
- (search arguments conversation_id request))
-
-;; TODO (Cam 10/28/25) -- fix this endpoint route to use kebab-case for consistency with the rest of our REST API
-#_{:clj-kondo/ignore [:metabase/validate-defendpoint-route-uses-kebab-case]}
-(api.macros/defendpoint :post "/search_v2" :- [:merge ::search-result ::tool-request]
- "Enhanced search with term and semantic queries using Reciprocal Rank Fusion. This is identical to /search, but
- duplicated in order to add a new capability to AI service that indicates that Metabot can search transforms. The
- /search endpoint is kept around for backward compatibility."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments {:optional true} ::search-arguments]]
- ::tool-request]
- request]
- (metabot-v3.context/log (assoc body :api :search_v2) :llm.log/llm->be)
- (search arguments conversation_id request))
-
-(api.macros/defendpoint :post "/get-snippets" :- [:merge ::get-snippets-result ::tool-request]
- "Get a list of all known SQL snippets."
- [_route-params
- _query-params
- {:keys [conversation_id] :as body} :- ::tool-request]
- (metabot-v3.context/log (assoc body :api :get-snippets) :llm.log/llm->be)
- (doto (-> (mc/decode ::get-snippets-result
- (metabot-v3.tools.snippets/get-snippets)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm)))
-
-(api.macros/defendpoint :post "/get-snippet-details" :- [:merge ::get-snippet-details-result ::tool-request]
- "Get the content of a single SQL snippet."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::get-snippet-details-arguments]]
- ::tool-request]]
-
- (metabot-v3.context/log (assoc body :api :get-snippet-details) :llm.log/llm->be)
- (let [arguments (mc/encode ::get-snippet-details-arguments arguments (mtx/transformer {:name :tool-api-request}))
- snippet-id (:snippet-id arguments)]
- (doto (-> (mc/decode ::get-snippet-details-result
- (metabot-v3.tools.snippets/get-snippet-details snippet-id)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
+ {:args-schema ::get-transform-python-library-details-arguments
+ :result-schema ::get-transform-python-library-details-result
+ :handler metabot-v3.tools.transforms/get-transform-python-library-details})
(mr/def ::check-transform-dependencies-arguments
[:and
@@ -1188,20 +842,125 @@
[:bad_questions [:sequential ::broken-question]]]]]
[:map [:output :string]]])
-(api.macros/defendpoint :post "/check-transform-dependencies" :- [:merge ::check-transform-dependencies-result ::tool-request]
+(deftool "/check-transform-dependencies"
"Check a proposed edit to a transform and return details of cards or transforms that would be broken by the change."
- [_route-params
- _query-params
- {:keys [arguments conversation_id] :as body} :- [:merge
- [:map [:arguments ::check-transform-dependencies-arguments]]
- ::tool-request]]
- (metabot-v3.context/log (assoc body :api :check-transform-dependencies) :llm.log/llm->be)
- (let [arguments (mc/encode ::check-transform-dependencies-arguments arguments (mtx/transformer {:name :tool-api-request}))]
- (doto (-> (mc/decode ::check-transform-dependencies-result
- (metabot-v3.tools.dependencies/check-transform-dependencies arguments)
- (mtx/transformer {:name :tool-api-response}))
- (assoc :conversation_id conversation_id))
- (metabot-v3.context/log :llm.log/be->llm))))
+ {:args-schema ::check-transform-dependencies-arguments
+ :result-schema ::check-transform-dependencies-result
+ :handler metabot-v3.tools.dependencies/check-transform-dependencies})
+
+;;; ----------------------------------------------------- Querying ----------------------------------------------------
+
+(mr/def ::filter-records-arguments
+ [:and
+ [:map
+ [:data_source [:and
+ [:or
+ [:map
+ [:query [:map [:database :int]]]
+ [:query_id {:optional true} :string]]
+ [:map [:report_id :int]]
+ [:map [:table_id :string]]]
+ [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]]]
+ [:filters [:sequential ::filter]]]
+ [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+
+(deftool "/filter-records"
+ "Construct a query from a metric."
+ {:args-schema ::filter-records-arguments
+ :result-schema ::filtering-result
+ :handler metabot-v3.tools.filters/filter-records})
+
+(mr/def ::query-metric-arguments
+ [:and
+ [:map
+ [:metric_id :int]
+ [:filters {:optional true} [:maybe [:sequential ::filter]]]
+ [:group_by {:optional true} [:maybe [:sequential ::group-by]]]]
+ [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+
+(deftool "/query-metric"
+ "Construct a query from a metric."
+ {:args-schema ::query-metric-arguments
+ :result-schema ::filtering-result
+ :handler metabot-v3.tools.filters/query-metric})
+
+(mr/def ::query-model-arguments
+ [:and
+ [:map
+ [:model_id :int]
+ [:fields {:optional true} [:maybe [:sequential ::field]]]
+ [:filters {:optional true} [:maybe [:sequential ::filter]]]
+ [:aggregations {:optional true} [:maybe [:sequential ::aggregation]]]
+ [:group_by {:optional true} [:maybe [:sequential ::group-by]]]
+ [:order_by {:optional true} [:maybe [:sequential [:map
+ [:field ::field]
+ [:direction [:enum {:encode/tool-api-request keyword} "asc" "desc"]]]]]]
+ [:limit {:optional true} [:maybe :int]]]
+ [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+
+;; TODO tsplude - drop the `/query-model` endpoint and filter logic in favor of this
+(deftool "/query-model"
+ "Construct a query from a model."
+ {:args-schema ::query-model-arguments
+ :result-schema ::filtering-result
+ :handler metabot-v3.tools.filters/query-model})
+
+(mr/def ::query-datasource-arguments
+ [:and
+ [:map
+ [:table_id {:optional true} :int]
+ [:model_id {:optional true} :int]
+ [:fields {:optional true} [:maybe [:sequential ::field]]]
+ [:filters {:optional true} [:maybe [:sequential ::filter]]]
+ [:aggregations {:optional true} [:maybe [:sequential ::aggregation]]]
+ [:group_by {:optional true} [:maybe [:sequential ::group-by]]]
+ [:order_by {:optional true} [:maybe [:sequential [:map
+ [:field ::field]
+ [:direction [:enum {:encode/tool-api-request keyword} "asc" "desc"]]]]]]
+ [:limit {:optional true} [:maybe :int]]]
+ [:fn {:error/message "Exactly one of table_id and model_id required"}
+ #(= (count (select-keys % [:table_id :model_id])) 1)]
+ [:map {:encode/tool-api-request #(update-keys % metabot-v3.u/safe->kebab-case-en)}]])
+
+;; TODO tsplude - drop the `/query-model` endpoint and filter logic in favor of this
+(deftool "/query-datasource"
+ "Construct a query from a model or table data source."
+ {:args-schema ::query-datasource-arguments
+ :result-schema ::filtering-result
+ :handler metabot-v3.tools.filters/query-datasource})
+
+;;; --------------------------------------------------- SQL Snippets --------------------------------------------------
+
+(mr/def ::get-snippets-result
+ "Schema for SQL snippet list results"
+ [:map
+ {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output [:sequential ::basic-snippet]]])
+
+(deftool "/get-snippets"
+ "Get a list of all known SQL snippets."
+ {:result-schema ::get-snippets-result
+ :handler metabot-v3.tools.snippets/get-snippets})
+
+(mr/def ::get-snippet-details-arguments
+ [:and
+ [:map
+ [:snippet_id :int]]
+ [:map {:encode/tool-api-request
+ #(set/rename-keys % {:snippet_id :snippet-id})}]])
+
+(mr/def ::get-snippet-details-result
+ "Schema for SQL snippet detail results"
+ [:map {:decode/tool-api-response #(update-keys % metabot-v3.u/safe->snake_case_en)}
+ [:structured_output ::full-snippet]])
+
+(deftool "/get-snippet-details"
+ "Get the content of a single SQL snippet."
+ {:args-schema ::get-snippet-details-arguments
+ :result-schema ::get-snippet-details-result
+ :handler metabot-v3.tools.snippets/get-snippet-details})
+
+;;; --------------------------------------------------- Middleware ----------------------------------------------------
(defn- enforce-authentication
"Middleware that returns a 401 response if no `ai-session` can be found for `request`."
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/deftool.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/deftool.clj
new file mode 100644
index 00000000000..12e909b0da7
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/deftool.clj
@@ -0,0 +1,94 @@
+(ns metabase-enterprise.metabot-v3.tools.deftool
+ "Macro for defining metabot tool endpoints with standard encoding/decoding behavior."
+ (:require
+ [malli.core :as mc]
+ [malli.transform :as mtx]
+ [metabase-enterprise.metabot-v3.context :as metabot-v3.context]
+ [metabase.api.macros :as api.macros]
+ [metabase.util.malli.registry :as mr]
+ [metabase.util.malli.schema :as ms]))
+
+;;; ---------------------------------------------------- Schemas ----------------------------------------------------
+
+(mr/def ::tool-request
+ "Base schema for all tool requests. Contains the conversation ID."
+ [:map [:conversation_id ms/UUIDString]])
+
+(def ^:private request-transformer
+ "Transformer for encoding tool request arguments (snake_case -> kebab-case)."
+ (mtx/transformer {:name :tool-api-request}))
+
+(def ^:private response-transformer
+ "Transformer for decoding tool response data (kebab-case -> snake_case)."
+ (mtx/transformer {:name :tool-api-response}))
+
+(defn invoke-tool
+ "Core tool invocation logic. Handles encoding, calling the handler, decoding, and logging.
+ This is the runtime implementation called by endpoints generated by `deftool`.
+
+ Arguments:
+ - `body` - The request body containing `:arguments` and `:conversation_id`
+ - `request` - The Ring request map (used to extract `:metabot-v3/metabot-id`)
+ - `opts` - A map with:
+ - `:api-name` - Keyword name for logging (e.g., `:field-values`)
+ - `:args-schema` - Malli schema for encoding arguments (optional)
+ - `:result-schema` - Malli schema for decoding results (optional)
+ - `:handler` - Function to call with encoded arguments (receives args map with :metabot-id)
+
+ The handler receives a single map argument containing the encoded args plus `:metabot-id`
+ (extracted from the request). For no-args tools, the handler receives just `{:metabot-id ...}`."
+ [{:keys [arguments conversation_id] :as body}
+ request
+ {:keys [api-name args-schema result-schema handler]}]
+ (metabot-v3.context/log (assoc body :api api-name) :llm.log/llm->be)
+ (let [metabot-id (:metabot-v3/metabot-id request)
+ encoded-args (cond-> (if args-schema
+ (mc/encode args-schema arguments request-transformer)
+ {})
+ metabot-id (assoc :metabot-id metabot-id))
+ raw-result (handler encoded-args)
+ result (if result-schema
+ (mc/decode result-schema raw-result response-transformer)
+ raw-result)]
+ (doto (assoc result :conversation_id conversation_id)
+ (metabot-v3.context/log :llm.log/be->llm))))
+
+(defmacro deftool
+ "Define a tool endpoint with standard encoding/decoding and logging behavior.
+
+ This macro generates a `defendpoint` with the boilerplate needed for tool endpoints:
+ - Logging incoming requests and outgoing responses
+ - Encoding arguments from snake_case to kebab-case (via `:tool-api-request` transformer)
+ - Decoding results from kebab-case to snake_case (via `:tool-api-response` transformer)
+ - Attaching `conversation_id` to responses
+ - Extracting `:metabot-id` from the request and including it in the args map
+
+ Options:
+ :args-schema - Malli schema for arguments (optional - omit for no-args tools)
+ :args-optional? - If true, arguments are marked as optional in the request body schema
+ :result-schema - Malli schema for result (required for response schema generation)
+ :handler - Function to call. Always receives an args map (may be empty for no-args tools)
+ with `:metabot-id` included when available from the request.
+
+ Example:
+ (deftool \"/field-values\"
+ \"Return statistics and/or values for a given field.\"
+ {:args-schema ::field-values-arguments
+ :result-schema ::field-values-result
+ :handler metabot-v3.tools.field-stats/field-values})"
+ [route docstring {:keys [args-schema args-optional? result-schema handler]}]
+ (let [api-name (keyword (subs route 1)) ; "/field-values" -> :field-values
+ body-schema (if args-schema
+ (if args-optional?
+ `[:merge [:map [:arguments {:optional true} ~args-schema]] ::tool-request]
+ `[:merge [:map [:arguments ~args-schema]] ::tool-request])
+ `::tool-request)
+ response-schema `[:merge ~result-schema ::tool-request]
+ tool-opts {:api-name api-name
+ :args-schema args-schema
+ :result-schema result-schema
+ :handler handler}]
+ `(api.macros/defendpoint :post ~route :- ~response-schema
+ ~docstring
+ [~'_route-params ~'_query-params ~'body :- ~body-schema ~'request]
+ (invoke-tool ~'body ~'request ~tool-opts))))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/dummy_tools.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/entity_details.clj
similarity index 94%
rename from enterprise/backend/src/metabase_enterprise/metabot_v3/dummy_tools.clj
rename to enterprise/backend/src/metabase_enterprise/metabot_v3/tools/entity_details.clj
index 1f8b3605f03..2c9532d195a 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/dummy_tools.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/entity_details.clj
@@ -1,6 +1,7 @@
-(ns metabase-enterprise.metabot-v3.dummy-tools
+(ns metabase-enterprise.metabot-v3.tools.entity-details
(:require
[medley.core :as m]
+ [metabase-enterprise.metabot-v3.config :as metabot-v3.config]
[metabase-enterprise.metabot-v3.tools.util :as metabot-v3.tools.u]
[metabase.api.common :as api]
[metabase.documents.core :as documents]
@@ -10,13 +11,14 @@
[metabase.lib.types.isa :as lib.types.isa]
[metabase.util :as u]
[metabase.util.humanization :as u.humanization]
+ [metabase.util.i18n :as i18n]
[metabase.util.log :as log]
[metabase.warehouse-schema.models.field-values :as field-values]
[toucan2.core :as t2]))
(set! *warn-on-reflection* true)
-(defn- verified-review?
+(defn verified-review?
"Return true if the most recent ModerationReview for the given item id/type is verified."
[id item-type]
(let [review (t2/select-one [:model/ModerationReview :status]
@@ -49,7 +51,7 @@
(defn get-current-user
"Get information about the current user."
- []
+ [_args]
(if-let [{:keys [id email first_name last_name]}
(or (some-> api/*current-user* deref)
(t2/select-one [:model/User :id :email :first_name :last_name] api/*current-user-id*))]
@@ -295,19 +297,21 @@
cards)))
(defn answer-sources
- "Get the details of metrics and models in the scope of the Metabot instance with ID `metabot-id`."
- ([metabot-id]
- (answer-sources metabot-id nil))
- ([metabot-id options]
- (lib-be/with-metadata-provider-cache
- (let [metrics-and-models (metabot-v3.tools.u/get-metrics-and-models metabot-id)
- {metrics :metric, models :model}
- (->> (for [[[card-type database-id] cards] (group-by (juxt :type :database_id) metrics-and-models)
- detail (cards-details card-type database-id cards options)]
- detail)
- (group-by :type))]
- {:structured-output {:metrics (vec metrics)
- :models (vec models)}}))))
+ "Get the details of metrics and models in the scope of the Metabot instance with ID `metabot-id`.
+ Accepts a map with `:metabot-id` and optional options for field values."
+ [{:keys [metabot-id] :as options}]
+ (if-let [normalized-metabot-id (metabot-v3.config/normalize-metabot-id metabot-id)]
+ (lib-be/with-metadata-provider-cache
+ (let [metrics-and-models (metabot-v3.tools.u/get-metrics-and-models normalized-metabot-id)
+ {metrics :metric, models :model}
+ (->> (for [[[card-type database-id] cards] (group-by (juxt :type :database_id) metrics-and-models)
+ detail (cards-details card-type database-id cards options)]
+ detail)
+ (group-by :type))]
+ {:structured-output {:metrics (vec metrics)
+ :models (vec models)}}))
+ (throw (ex-info (i18n/tru "Invalid metabot_id {0}" metabot-id)
+ {:metabot_id metabot-id, :status-code 400}))))
(comment
(binding [api/*current-user-permissions-set* (delay #{"/"})
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
index fd59492d8cb..cc6501ce337 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/search.clj
@@ -213,3 +213,15 @@
(take limit)
(map postprocess-search-result)
enrich-with-collection-descriptions)))
+
+(defn search-tool
+ "Handler for the /search and /search_v2 tool endpoints.
+ Wraps [[search]] with error handling and response formatting."
+ [args]
+ (try
+ (let [results (search args)]
+ {:structured_output {:data results
+ :total_count (count results)}})
+ (catch Exception e
+ (log/error e "Error in search")
+ {:output (str "Search failed: " (or (ex-message e) "Unknown error"))})))
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj
index b029ecd9526..a9b47538e95 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/snippets.clj
@@ -5,7 +5,7 @@
(defn get-snippets
"Lists SQL snippets available to the current user."
- []
+ [_args]
(try
{:structured_output
(->> (snippets/list-native-query-snippets)
@@ -15,7 +15,7 @@
(defn get-snippet-details
"Retrieve a specific SQL snippet by ID, including its content."
- [snippet-id]
+ [{:keys [snippet-id]}]
(try
{:structured_output
(when snippet-id
diff --git a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj
index 768525b32bd..314430b0eb0 100644
--- a/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj
+++ b/enterprise/backend/src/metabase_enterprise/metabot_v3/tools/transforms.clj
@@ -11,7 +11,7 @@
(defn get-transforms
"Get a list of all known transforms."
- []
+ [_args]
(try
{:structured_output
(->> (api.transforms/get-transforms)
@@ -23,7 +23,7 @@
(defn get-transform-details
"Get information about a transform."
- [transform-id]
+ [{:keys [transform-id]}]
(try
{:structured_output
(api.transforms/get-transform transform-id)}
@@ -32,7 +32,7 @@
(defn get-transform-python-library-details
"Get information about a Python library by path."
- [path]
+ [{:keys [path]}]
(try
{:structured_output
(transforms-python.api/get-python-library-by-path path)}
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
index e0ac10684c9..1511b8f4d98 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/api_test.clj
@@ -5,10 +5,10 @@
[malli.transform :as mtx]
[medley.core :as m]
[metabase-enterprise.metabot-v3.client :as metabot-v3.client]
- [metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.tools.dummy-tools]
[metabase-enterprise.metabot-v3.tools.api :as metabot-v3.tools.api]
[metabase-enterprise.metabot-v3.tools.create-dashboard-subscription :as metabot-v3.tools.create-dashboard-subscription]
[metabase-enterprise.metabot-v3.tools.dependencies-test :as metabot-v3.tools.dependencies-test]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as metabot-v3.tools.entity-details]
[metabase-enterprise.metabot-v3.tools.filters :as metabot-v3.tools.filters]
[metabase-enterprise.metabot-v3.tools.find-outliers :as metabot-v3.tools.find-outliers]
[metabase-enterprise.metabot-v3.tools.generate-insights :as metabot-v3.tools.generate-insights]
@@ -61,12 +61,12 @@
:hour 15
:day_of_month "middle-of-month"}}
:conversation_id conversation-id})]
- (is (= [{:dashboard-id 1
- :schedule {:frequency :monthly
- :hour 15
- :day-of-month :middle-of-month}}]
- @tool-requests))
+ (is (=? [{:dashboard-id 1
+ :schedule {:frequency :monthly
+ :hour 15
+ :day-of-month :middle-of-month}}]
+ @tool-requests))
(is (=? {:output output
:conversation_id conversation-id}
response)))))))
@@ -393,7 +393,7 @@
:model/Card {model-id :id} (assoc model-data :collection_id collection-id)
:model/Metabot {metabot-eid :entity_id} {:name "Test Metabot"
:collection_id collection-id}]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [model-metric-base-query (lib/query mp (lib.metadata/card mp model-id))
rating-column (m/find-first (comp #{"RATING"} :name) (lib/visible-columns model-metric-base-query))
created-at-column (m/find-first (comp #{"CREATED_AT"} :name) (lib/breakoutable-columns model-metric-base-query))
@@ -519,7 +519,7 @@
(mt/with-premium-features #{:metabot-v3}
(let [dash-data {:name "dashing dash", :description "dash description"}]
(mt/with-temp [:model/Dashboard {dash-id :id} dash-data]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [conversation-id (str (random-uuid))
ai-token (ai-session-token)
response (mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-dashboard-details"
@@ -590,7 +590,7 @@
{:arguments arguments
:conversation_id conversation-id}))]
(mt/with-temp [:model/Card {metric-id :id} metric-data]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(testing "Normal call"
(is (=? {:structured_output (-> metric-data
(select-keys [:name :display_name :description])
@@ -689,7 +689,7 @@
:dataset_query (lib/->legacy-MBQL source-query)
:type :question}]
(mt/with-temp [:model/Card {question-id :id} question-data]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [conversation-id (str (random-uuid))
ai-token (ai-session-token)
arguments {:report_id question-id}
@@ -832,7 +832,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
@@ -876,7 +876,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
@@ -925,7 +925,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
@@ -961,7 +961,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
@@ -999,7 +999,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
@@ -1034,7 +1034,7 @@
{:source-table (str "card__" model-id)
:aggregation [[:count]]
:breakout [!month.*created_at *quantity]}))]
- (with-redefs [metabot-v3.tools.dummy-tools/verified-review? (constantly true)]
+ (with-redefs [metabot-v3.tools.entity-details/verified-review? (constantly true)]
(let [request (fn [arguments]
(mt/user-http-request :rasta :post 200 "ee/metabot-tools/get-table-details"
{:request-options {:headers {"x-metabase-session" ai-token}}}
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/deftool_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/deftool_test.clj
new file mode 100644
index 00000000000..4b8d083cef9
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/deftool_test.clj
@@ -0,0 +1,108 @@
+(ns metabase-enterprise.metabot-v3.tools.deftool-test
+ (:require
+ [clojure.set :as set]
+ [clojure.test :refer [deftest is testing]]
+ [metabase-enterprise.metabot-v3.tools.deftool :as deftool]
+ [metabase.util.malli.registry :as mr]))
+
+;;; ---------------------------------------------------- invoke-tool tests ----------------------------------------------------
+
+(deftest ^:parallel invoke-tool-no-args-test
+ (testing "invoke-tool with no arguments schema passes metabot-id in args"
+ (let [received-args (atom nil)
+ handler (fn [args]
+ (reset! received-args args)
+ {:structured_output {:message "hello"}})
+ body {:conversation_id "conv-123"}
+ request {:metabot-v3/metabot-id "bot-456"}
+ opts {:api-name :test-tool
+ :handler handler
+ :result-schema nil}
+ result (deftool/invoke-tool body request opts)]
+ (is (= {:metabot-id "bot-456"} @received-args) "Handler should receive metabot-id in args")
+ (is (= "conv-123" (:conversation_id result)))
+ (is (= {:message "hello"} (:structured_output result)))))
+
+ (testing "invoke-tool with no arguments schema and no metabot-id"
+ (let [received-args (atom nil)
+ handler (fn [args]
+ (reset! received-args args)
+ {:structured_output {:message "hello"}})
+ body {:conversation_id "conv-123"}
+ request {}
+ opts {:api-name :test-tool
+ :handler handler
+ :result-schema nil}
+ result (deftool/invoke-tool body request opts)]
+ (is (= {} @received-args) "Handler should receive empty args when no metabot-id")
+ (is (= "conv-123" (:conversation_id result))))))
+
+(deftest ^:parallel invoke-tool-with-args-test
+ (testing "invoke-tool with arguments schema that encodes keys"
+ (mr/def ::test-args
+ [:and
+ [:map [:user_id :int]]
+ [:map {:encode/tool-api-request #(set/rename-keys % {:user_id :user-id})}]])
+ (let [received-args (atom nil)
+ handler (fn [args]
+ (reset! received-args args)
+ {:structured_output {:processed true}})
+ body {:arguments {:user_id 42}
+ :conversation_id "conv-456"}
+ request {:metabot-v3/metabot-id "bot-789"}
+ opts {:api-name :test-tool
+ :args-schema ::test-args
+ :handler handler
+ :result-schema nil}
+ result (deftool/invoke-tool body request opts)]
+ (is (= {:user-id 42, :metabot-id "bot-789"} @received-args)
+ "Arguments should be encoded with schema transformer and include metabot-id")
+ (is (= "conv-456" (:conversation_id result))))))
+
+(deftest ^:parallel invoke-tool-with-result-decoding-test
+ (testing "invoke-tool decodes results using result-schema"
+ (mr/def ::test-result
+ [:map {:decode/tool-api-response #(set/rename-keys % {:user-name :user_name})}
+ [:user_name :string]])
+ (let [handler (fn [_args]
+ {:user-name "Alice"})
+ body {:conversation_id "conv-789"}
+ request {}
+ opts {:api-name :test-tool
+ :handler handler
+ :result-schema ::test-result}
+ result (deftool/invoke-tool body request opts)]
+ (is (= "Alice" (:user_name result)) "Result should be decoded with schema transformer")
+ (is (= "conv-789" (:conversation_id result))))))
+
+;;; ---------------------------------------------------- deftool macro tests ----------------------------------------------------
+
+(deftest ^:parallel deftool-macro-expansion-test
+ (testing "deftool macro expands to a defendpoint form"
+ (let [expansion (macroexpand-1 '(metabase-enterprise.metabot-v3.tools.deftool/deftool "/test-endpoint"
+ "Test docstring"
+ {:args-schema ::my-args
+ :result-schema ::my-result
+ :handler identity}))]
+ (is (seq? expansion) "Should expand to a form")
+ (is (= 'metabase.api.macros/defendpoint (first expansion)))
+ (is (= :post (second expansion)))
+ (is (= "/test-endpoint" (nth expansion 2)))))
+
+ (testing "deftool macro expands correctly for no-args tool"
+ (let [expansion (macroexpand-1 '(metabase-enterprise.metabot-v3.tools.deftool/deftool "/no-args"
+ "No args tool"
+ {:result-schema ::my-result
+ :handler identity}))]
+ (is (seq? expansion))
+ (is (= 'metabase.api.macros/defendpoint (first expansion)))))
+
+ (testing "deftool macro always includes request in binding vector"
+ (let [expansion (macroexpand-1 '(metabase-enterprise.metabot-v3.tools.deftool/deftool "/test"
+ "Test"
+ {:result-schema ::my-result
+ :handler identity}))]
+ (is (seq? expansion))
+ ;; The expansion should include 'request' in the binding vector
+ (let [binding-vec (nth expansion 6)]
+ (is (some #{'request} binding-vec) "Should include request binding")))))
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/dummy_tools_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/entity_details_test.clj
similarity index 86%
rename from enterprise/backend/test/metabase_enterprise/metabot_v3/dummy_tools_test.clj
rename to enterprise/backend/test/metabase_enterprise/metabot_v3/tools/entity_details_test.clj
index a1eb9141269..47ca9be27df 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/dummy_tools_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/entity_details_test.clj
@@ -1,7 +1,7 @@
-(ns metabase-enterprise.metabot-v3.dummy-tools-test
+(ns metabase-enterprise.metabot-v3.tools.entity-details-test
(:require
[clojure.test :refer :all]
- [metabase-enterprise.metabot-v3.dummy-tools :as dummy-tools]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as entity-details]
[metabase.lib.core :as lib]
[metabase.test :as mt]
[metabase.test.fixtures :as fixtures]))
@@ -10,9 +10,9 @@
(deftest get-document-details-invalid-document-id-test
(testing "returns error for invalid document-id"
- (is (= {:output "invalid document_id"} (dummy-tools/get-document-details {:document-id "invalid"})))
- (is (= {:output "invalid document_id"} (dummy-tools/get-document-details {:document-id nil})))
- (is (= {:output "invalid document_id"} (dummy-tools/get-document-details {:document-id 1.5})))))
+ (is (= {:output "invalid document_id"} (entity-details/get-document-details {:document-id "invalid"})))
+ (is (= {:output "invalid document_id"} (entity-details/get-document-details {:document-id nil})))
+ (is (= {:output "invalid document_id"} (entity-details/get-document-details {:document-id 1.5})))))
(deftest get-document-details-valid-document-test
(testing "returns document details for valid document-id"
@@ -22,7 +22,7 @@
:collection_id coll-id
:creator_id (mt/user->id :crowberto)}]
(mt/with-current-user (mt/user->id :crowberto)
- (let [result (dummy-tools/get-document-details {:document-id doc-id})]
+ (let [result (entity-details/get-document-details {:document-id doc-id})]
(is (contains? result :structured-output))
(let [doc-info (:structured-output result)]
(is (= doc-id (:id doc-info)))
@@ -32,7 +32,7 @@
(deftest get-document-details-nonexistent-document-test
(testing "returns 'document not found' for non-existent document"
- (let [result (dummy-tools/get-document-details {:document-id 99999})]
+ (let [result (entity-details/get-document-details {:document-id 99999})]
(is (= {:output "error fetching document: Not found."} result)))))
(deftest get-document-details-archived-document-test
@@ -44,7 +44,7 @@
:creator_id (mt/user->id :crowberto)
:archived true}]
(mt/with-current-user (mt/user->id :crowberto)
- (let [result (dummy-tools/get-document-details {:document-id doc-id})]
+ (let [result (entity-details/get-document-details {:document-id doc-id})]
(is (contains? result :structured-output))
(let [doc-info (:structured-output result)]
(is (= doc-id (:id doc-info)))
@@ -57,7 +57,7 @@
:document "{\"type\":\"doc\"}"
:creator_id (mt/user->id :crowberto)}]
(mt/with-current-user (mt/user->id :crowberto)
- (let [result (dummy-tools/get-document-details {:document-id doc-id})]
+ (let [result (entity-details/get-document-details {:document-id doc-id})]
(is (contains? result :structured-output))
(let [doc-info (:structured-output result)]
(is (= doc-id (:id doc-info)))
@@ -70,7 +70,7 @@
:document ""
:creator_id (mt/user->id :crowberto)}]
(mt/with-current-user (mt/user->id :crowberto)
- (let [result (dummy-tools/get-document-details {:document-id doc-id})]
+ (let [result (entity-details/get-document-details {:document-id doc-id})]
(is (contains? result :structured-output))
(let [doc-info (:structured-output result)]
(is (= doc-id (:id doc-info)))
@@ -85,7 +85,7 @@
:creator_id (mt/user->id :crowberto)}]
(mt/with-current-user (mt/user->id :rasta)
(is (= {:output "error fetching document: You don't have permissions to do that."}
- (dummy-tools/get-document-details {:document-id doc-id}))))))))
+ (entity-details/get-document-details {:document-id doc-id}))))))))
(deftest get-query-details-mbql-v4-test
(testing "get-query-details works with MBQL v4 (legacy) queries"
@@ -95,7 +95,7 @@
:type :query
:query {:source-table (mt/id :venues)
:limit 10}}
- result (dummy-tools/get-query-details {:query legacy-query})]
+ result (entity-details/get-query-details {:query legacy-query})]
(is (contains? result :structured-output))
(let [output (:structured-output result)]
(is (= :query (:type output)))
@@ -110,7 +110,7 @@
(mt/test-driver :h2
(mt/with-current-user (mt/user->id :crowberto)
(let [mbql-v5-query (lib/query (mt/metadata-provider) (mt/mbql-query venues {:limit 10}))
- result (dummy-tools/get-query-details {:query mbql-v5-query})]
+ result (entity-details/get-query-details {:query mbql-v5-query})]
(is (contains? result :structured-output))
(let [output (:structured-output result)]
(is (= :query (:type output)))
@@ -125,7 +125,7 @@
(mt/test-driver :h2
(mt/with-current-user (mt/user->id :crowberto)
(let [native-query (lib/native-query (mt/metadata-provider) "SELECT * FROM VENUES LIMIT 10")
- result (dummy-tools/get-query-details {:query native-query})]
+ result (entity-details/get-query-details {:query native-query})]
(is (contains? result :structured-output))
(let [output (:structured-output result)]
(is (= :query (:type output)))
@@ -144,7 +144,7 @@
products-query (lib/query (mt/metadata-provider) (mt/mbql-query products))
expected-products-field-count (count (lib/visible-columns products-query -1 {:include-implicitly-joinable? false}))
;; Get Orders table details with related tables
- result (dummy-tools/get-table-details {:table-id orders-id})
+ result (entity-details/get-table-details {:table-id orders-id})
output (:structured-output result)
related-tables (:related_tables output)
products-related (first (filter #(= products-id (:id %)) related-tables))]
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/filters_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/filters_test.clj
index ad12a2cd6dc..869ecd9daef 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/filters_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/filters_test.clj
@@ -2,7 +2,7 @@
(:require
[clojure.test :refer :all]
[medley.core :as m]
- [metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.dummy-tools]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as metabot-v3.tools.entity-details]
[metabase-enterprise.metabot-v3.tools.filters :as metabot-v3.tools.filters]
[metabase.lib.convert :as lib.convert]
[metabase.lib.core :as lib]
@@ -37,7 +37,7 @@
:filters []
:group-by []}))))
(mt/with-current-user (mt/user->id :crowberto)
- (let [metric-details (metabot-v3.dummy-tools/metric-details metric-id)
+ (let [metric-details (metabot-v3.tools.entity-details/metric-details metric-id)
->field-id #(u/prog1 (-> metric-details :queryable-dimensions (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))]
@@ -175,7 +175,7 @@
:filters []
:group-by []}))))
(mt/with-current-user (mt/user->id :crowberto)
- (let [model-details (-> (metabot-v3.dummy-tools/get-table-details {:model-id model-id})
+ (let [model-details (-> (metabot-v3.tools.entity-details/get-table-details {:model-id model-id})
:structured-output)
model-card-id (str "card__" model-id)
->field-id #(u/prog1 (-> model-details :fields (by-name %) :field_id)
@@ -314,7 +314,7 @@
(mt/with-current-user (mt/user->id :crowberto)
(let [mp (mt/metadata-provider)
table-id (mt/id :orders)
- table-details (#'metabot-v3.dummy-tools/table-details table-id {:metadata-provider mp})
+ table-details (#'metabot-v3.tools.entity-details/table-details table-id {:metadata-provider mp})
->field-id #(u/prog1 (-> table-details :fields (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))]
@@ -373,7 +373,7 @@
{:data-source {:table-id (str "card__" model-id)}
:filters []}))))
(mt/with-current-user (mt/user->id :crowberto)
- (let [model-details (#'metabot-v3.dummy-tools/card-details model-id)
+ (let [model-details (#'metabot-v3.tools.entity-details/card-details model-id)
table-id (str "card__" model-id)
->field-id #(u/prog1 (-> model-details :fields (by-name %) :field_id)
(when-not <>
@@ -420,7 +420,7 @@
{:data-source {:report-id card-id}
:filters []}))))
(mt/with-current-user (mt/user->id :crowberto)
- (let [report-details (#'metabot-v3.dummy-tools/card-details card-id)
+ (let [report-details (#'metabot-v3.tools.entity-details/card-details card-id)
->field-id #(u/prog1 (-> report-details :fields (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))]
@@ -461,7 +461,7 @@
query (lib/query mp (lib.metadata/table mp table-id))
legacy-query (lib.convert/->legacy-MBQL query)
query-details (mt/with-current-user (mt/user->id :crowberto)
- (#'metabot-v3.dummy-tools/execute-query query-id legacy-query))
+ (#'metabot-v3.tools.entity-details/execute-query query-id legacy-query))
->field-id #(u/prog1 (-> query-details :result-columns (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))
@@ -498,7 +498,7 @@
(mt/with-current-user (mt/user->id :crowberto)
(let [mp (mt/metadata-provider)
table-id (mt/id :orders)
- table-details (#'metabot-v3.dummy-tools/table-details table-id {:metadata-provider mp})
+ table-details (#'metabot-v3.tools.entity-details/table-details table-id {:metadata-provider mp})
->field-id #(u/prog1 (-> table-details :fields (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))]
@@ -600,7 +600,7 @@
:description "Test model for orders"
:type :model}]
(mt/with-current-user (mt/user->id :crowberto)
- (let [model-details (-> (metabot-v3.dummy-tools/get-table-details {:model-id model-id})
+ (let [model-details (-> (metabot-v3.tools.entity-details/get-table-details {:model-id model-id})
:structured-output)
model-card-id (str "card__" model-id)
->field-id #(u/prog1 (-> model-details :fields (by-name %) :field_id)
diff --git a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/find_outliers_test.clj b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/find_outliers_test.clj
index bd7e720027b..c443d938b2f 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/find_outliers_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot_v3/tools/find_outliers_test.clj
@@ -3,7 +3,7 @@
[clojure.test :refer :all]
[medley.core :as m]
[metabase-enterprise.metabot-v3.client :as metabot-v3.client]
- [metabase-enterprise.metabot-v3.dummy-tools :as metabot-v3.dummy-tools]
+ [metabase-enterprise.metabot-v3.tools.entity-details :as metabot-v3.tools.entity-details]
[metabase-enterprise.metabot-v3.tools.find-outliers :as metabot-v3.tools.find-outliers]
[metabase.lib.convert :as lib.convert]
[metabase.lib.core :as lib]
@@ -69,7 +69,7 @@
(deftest report-find-outliers-test
(mt/with-temp [:model/Card {report-id :id} (assoc (test-card) :type :question)]
(let [report-details (mt/with-current-user (mt/user->id :crowberto)
- (#'metabot-v3.dummy-tools/card-details report-id))
+ (#'metabot-v3.tools.entity-details/card-details report-id))
->field-id #(u/prog1 (-> report-details :fields (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))
@@ -81,7 +81,7 @@
(deftest query-find-outliers-test
(let [query-id (u/generate-nano-id)
query-details (mt/with-current-user (mt/user->id :crowberto)
- (#'metabot-v3.dummy-tools/execute-query query-id (:dataset_query (test-card))))
+ (#'metabot-v3.tools.entity-details/execute-query query-id (:dataset_query (test-card))))
->field-id #(u/prog1 (-> query-details :result-columns (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))
@@ -117,7 +117,7 @@
(deftest ^:parallel find-outliers-wrong-query-test
(let [query-id (u/generate-nano-id)
query-details (mt/with-current-user (mt/user->id :crowberto)
- (#'metabot-v3.dummy-tools/execute-query query-id (:dataset_query (test-card))))
+ (#'metabot-v3.tools.entity-details/execute-query query-id (:dataset_query (test-card))))
->field-id #(u/prog1 (-> query-details :result-columns (by-name %) :field_id)
(when-not <>
(throw (ex-info (str "Column " % " not found") {:column %}))))
diff --git a/src/metabase/driver/sql_jdbc/connection.clj b/src/metabase/driver/sql_jdbc/connection.clj
index bb29e601d51..633de7e691c 100644
--- a/src/metabase/driver/sql_jdbc/connection.clj
+++ b/src/metabase/driver/sql_jdbc/connection.clj
@@ -1,7 +1,7 @@
(ns metabase.driver.sql-jdbc.connection
"Logic for creating and managing connection pools for SQL JDBC drivers. Implementations for connection-related driver
multimethods for SQL JDBC drivers."
- (:refer-clojure :exclude [some select-keys get-in])
+ (:refer-clojure :exclude [get-in some select-keys])
(:require
[clojure.java.jdbc :as jdbc]
[metabase.driver :as driver]
@@ -13,7 +13,7 @@
[metabase.util.i18n :refer [tru]]
[metabase.util.log :as log]
[metabase.util.malli :as mu]
- [metabase.util.performance :refer [some select-keys get-in]]
+ [metabase.util.performance :refer [get-in select-keys some]]
[potemkin :as p]
^{:clj-kondo/ignore [:discouraged-namespace]}
[toucan2.core :as t2])