@magemetrics/core 0.0.60 → 0.1.0

package/dist/index.d.ts

@@ -1,5 +1,10 @@
 import { Client } from 'openapi-fetch';
+import { DefaultChatTransport } from 'ai';
+import { HttpChatTransportInitOptions } from 'ai';
+import type { InferUITool } from 'ai';
 import type { Simplify } from 'type-fest';
+import type { Tool } from 'ai';
+import type { UIMessage } from 'ai';
 import { z } from 'zod';
 
 /**
@@ -212,6 +217,21 @@ declare interface components {
     pathItems: never;
 }
 
+/**
+ * Parameters for starting a flow
+ */
+export declare type CreateFlowParam = {
+    query: string;
+} | {
+    triggerId: string;
+    variables: Record<string, string>;
+};
+
+declare type CustomDataParts = {
+    "quick-actions": z.infer<typeof QuickActionsSchema>;
+    signal: z.infer<typeof SignalWithReportIdSchema>;
+};
+
 declare type ExtractInsightResponse = z.infer<typeof ExtractInsightResponseSchema>;
 
 declare const ExtractInsightResponseSchema: z.ZodUnion<[z.ZodObject<{
@@ -381,8 +401,92 @@ export declare type GenerateInsightParam = {
 
 export declare const getPublicApiClient: (apiUrl: string, apiKey: string) => Client<NoAuthPaths>;
 
+declare const inputSchema: z.ZodObject<{
+    userRequest: z.ZodString;
+    isNewAnalysisGoal: z.ZodBoolean;
+    responseType: z.ZodEnum<["text", "table", "visualization"]>;
+    difficultyLevel: z.ZodEnum<["simple", "moderate", "complex"]>;
+}, "strip", z.ZodTypeAny, {
+    userRequest: string;
+    isNewAnalysisGoal: boolean;
+    responseType: "text" | "table" | "visualization";
+    difficultyLevel: "simple" | "moderate" | "complex";
+}, {
+    userRequest: string;
+    isNewAnalysisGoal: boolean;
+    responseType: "text" | "table" | "visualization";
+    difficultyLevel: "simple" | "moderate" | "complex";
+}>;
+
+declare const inputSchema_2: z.ZodObject<{
+    chartType: z.ZodEnum<["bar", "line/area", "scatter", "pie"]>;
+    columnConfiguration: z.ZodObject<{
+        dimensionColumn: z.ZodString;
+        valueColumns: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        dimensionColumn: string;
+        valueColumns: string[];
+    }, {
+        dimensionColumn: string;
+        valueColumns: string[];
+    }>;
+    explanations: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chartType: "bar" | "line/area" | "scatter" | "pie";
+    columnConfiguration: {
+        dimensionColumn: string;
+        valueColumns: string[];
+    };
+    explanations: string;
+}, {
+    chartType: "bar" | "line/area" | "scatter" | "pie";
+    columnConfiguration: {
+        dimensionColumn: string;
+        valueColumns: string[];
+    };
+    explanations: string;
+}>;
+
+declare const inputSchema_3: z.ZodObject<{
+    thought: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+}, {
+    thought: string;
+}>;
+
+declare const inputSchema_4: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+
+declare const inputSchema_5: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+
+declare const inputSchema_6: z.ZodObject<{
+    table_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    table_name: string;
+}, {
+    table_name: string;
+}>;
+
+declare const inputSchema_7: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+
 declare type InternalApiClient = Simplify<Client<NoAuthPaths, `${string}/${string}`>>;
 
+export declare class MageMetricsChatTransport extends DefaultChatTransport<MMChatUIMessage> {
+    constructor(apiUrl: string, flowId: string, options?: Omit<HttpChatTransportInitOptions<MMChatUIMessage>, "api" | "headers" | "prepareSendMessagesRequest">);
+}
+
 /**
  * Core MageMetrics client that handles authentication lifecycle and provides
  * a promise-based API that automatically waits for authentication to complete.
@@ -431,13 +535,7 @@ export declare class MageMetricsClient {
         getRecentFlows: (params?: {
             limit?: number;
         }) => Promise<FrontendRecentFlows[]>;
-        /**
-         * @deprecated Use `createFlow` instead.
-         * @param request the user request
-         * @returns the id of the created flow
-         */
-        startFlow: (request: StartFlowParam) => Promise<string>;
-        createFlow: (request: StartFlowParam) => Promise<{
+        createFlow: (request: CreateFlowParam) => Promise<{
             flowId: string;
         }>;
         getDashboard: (dashboardId: string) => Promise<FrontendDashboard>;
@@ -525,6 +623,18 @@ export declare class MemoryStorageAdapter implements AsyncStorage {
     removeItem(key: string): Promise<void>;
 }
 
+declare type MMChatUIMessage = UIMessage<unknown, CustomDataParts, MMUiTools>;
+
+declare type MMUiTools = {
+    generateDataReport: UiTool;
+    generateVisualization: UiTool_2;
+    think: UiTool_3;
+    valueBasedColumnSearch: UiTool_4;
+    getAvailableTables: UiTool_5;
+    getAvailableColumnsForTable: UiTool_6;
+    webSearch: UiTool_7;
+};
+
 declare type NoAuthPaths = Simplify<{
     [Path in keyof paths]: RemoveAuthHeader<paths[Path]>;
 }>;
@@ -2463,7 +2573,7 @@ declare interface operations {
             };
         };
     };
-    getSankeyData: {
+    listSankeyUserFilters: {
         parameters: {
             query?: never;
             header?: never;
@@ -2471,6 +2581,58 @@ declare interface operations {
             cookie?: never;
         };
         requestBody?: never;
+        responses: {
+            /** @description List of available user filters */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                        field_key: string;
+                        display_name: string;
+                        /** @default true */
+                        is_active: boolean;
+                        /** @default false */
+                        include_visualization: boolean;
+                        values: (string | {
+                            label: string;
+                            value: string;
+                        })[];
+                    }[];
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getSankeyData: {
+        parameters: {
+            query?: {
+                user_id?: string;
+                cluster_id?: number | null;
+                subcluster_id?: number | null;
+                /** @description Comma-separated list of bins: lt0.6,0.6-0.8,0.8-1 (applies to average score) */
+                score_ranges?: string;
+                /** @description JSON-encoded map of { [field_key]: string[] } to be passed to RPC */
+                external_filters?: string;
+                max_results?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
         responses: {
             /** @description Sankey data retrieved successfully */
             200: {
@@ -2480,17 +2642,16 @@ declare interface operations {
                 content: {
                     "application/json": {
                         metadata: {
-                            embedding_type: string;
-                            approach: string;
                             total_clusters: number;
-                            total_noise_points: number;
                             total_requests: number;
                             generation_timestamp: string;
                         };
                         clusters: {
                             cluster_id: number;
+                            subcluster_id?: number | null;
                             cluster_name: string;
                             representative_questions: {
+                                subcluster_id: number;
                                 question: string;
                                 count: number;
                                 sample_requests: string[];
@@ -2503,6 +2664,27 @@ declare interface operations {
                             avg_assumptions_score?: number | null;
                             avg_friendliness_score?: number | null;
                         }[];
+                        rows?: {
+                            flow_data_id: number;
+                            company_id: number;
+                            main_cluster_id: number;
+                            main_cluster_name: string;
+                            subcluster_id: number | null;
+                            subcluster_name: string | null;
+                            core_question: string | null;
+                            /** Format: uuid */
+                            user_id: string;
+                            initial_user_request: string | null;
+                            flow_data_request: string | null;
+                            flow_data_created_at: string | null;
+                            confidence_score: number | null;
+                            assumptions_score: number | null;
+                            friendliness_score: number | null;
+                            user_email: string | null;
+                            external: {
+                                [key: string]: unknown;
+                            } | null;
+                        }[];
                     };
                 };
             };
@@ -3322,6 +3504,22 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/admin-console/usage-insights/filters": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listSankeyUserFilters"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/admin-console/usage-insights/sankey": {
         parameters: {
             query?: never;
@@ -3420,6 +3618,598 @@ declare interface paths {
     };
 }
 
+declare const QuickActionsSchema: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    explanation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    explanation: string;
+}, {
+    label: string;
+    explanation: string;
+}>, "many">;
+
+declare const redactedOutputSchema: z.ZodObject<{
+    tool: z.ZodLiteral<"generateDataReport">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            flowDataId: z.ZodNumber;
+            answer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        }, {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        }>;
+        private: z.ZodObject<{
+            sql: z.ZodString;
+            dataReportSummary: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sql: string;
+            dataReportSummary: string;
+        }, {
+            sql: string;
+            dataReportSummary: string;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "generateDataReport";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "generateDataReport";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_2: z.ZodObject<{
+    tool: z.ZodLiteral<"generateVisualization">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            flowDataId: z.ZodNumber;
+            flowDataVisualizationId: z.ZodNumber;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        }, {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        }>;
+        private: z.ZodObject<{
+            sql: z.ZodOptional<z.ZodString>;
+            dataReportSummary: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            sql?: string | undefined;
+            dataReportSummary?: string | undefined;
+        }, {
+            sql?: string | undefined;
+            dataReportSummary?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "generateVisualization";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "generateVisualization";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_3: z.ZodObject<{
+    tool: z.ZodLiteral<"valueBasedColumnSearch">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            message: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                name: z.ZodString;
+                data_type: z.ZodNullable<z.ZodString>;
+                description: z.ZodNullable<z.ZodString>;
+                null_percentage: z.ZodNullable<z.ZodNumber>;
+                unique_values: z.ZodNullable<z.ZodNumber>;
+                sample_values: z.ZodNullable<z.ZodArray<z.ZodAny, "many">>;
+                table: z.ZodObject<{
+                    table_name: z.ZodString;
+                    description: z.ZodNullable<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    description: string | null;
+                    table_name: string;
+                }, {
+                    description: string | null;
+                    table_name: string;
+                }>;
+                matched_values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }, {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }[];
+            message?: string | undefined;
+        }, {
+            columns: {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }[];
+            message?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "valueBasedColumnSearch";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "valueBasedColumnSearch";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_4: z.ZodObject<{
+    tool: z.ZodLiteral<"getAvailableTables">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            tables: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                table_name: z.ZodString;
+                description: z.ZodNullable<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }, {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            tables: {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }[];
+        }, {
+            tables: {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }[];
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "getAvailableTables";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "getAvailableTables";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_5: z.ZodObject<{
+    tool: z.ZodLiteral<"getAvailableColumnsForTable">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            message: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                name: z.ZodString;
+                data_type: z.ZodNullable<z.ZodString>;
+                description: z.ZodNullable<z.ZodString>;
+                null_percentage: z.ZodNullable<z.ZodNumber>;
+                unique_values: z.ZodNullable<z.ZodNumber>;
+                sample_values: z.ZodNullable<z.ZodArray<z.ZodAny, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }, {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }[];
+            message?: string | undefined;
+        }, {
+            columns: {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }[];
+            message?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "getAvailableColumnsForTable";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "getAvailableColumnsForTable";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_6: z.ZodObject<{
+    tool: z.ZodLiteral<"search">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                sourceType: z.ZodLiteral<"url">;
+                id: z.ZodString;
+                url: z.ZodString;
+                title: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }, {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        }, {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        }>;
+        private: z.ZodObject<{
+            answer: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            answer?: string | undefined;
+        }, {
+            answer?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "search";
+    result?: {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "search";
+    result?: {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const RedactedThinkResponse: z.ZodObject<{
+    tool: z.ZodDefault<z.ZodLiteral<"think">>;
+} & {
+    result: z.ZodOptional<z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "think";
+    result?: {
+        status: "success";
+        public: {};
+    } | undefined;
+}, {
+    tool?: "think" | undefined;
+    result?: {
+        status: "success";
+        public: {};
+    } | undefined;
+}>;
+
 declare type RemoveAuthHeader<PathSchema> = Simplify<{
     [Method in keyof PathSchema]: RemoveParams<PathSchema[Method], ToRemove>;
 }>;
@@ -3442,15 +4232,26 @@ declare type RemoveParamsConfig = Simplify<{
     cookie?: string;
 }>;
 
-/**
- * Parameters for starting a flow
- */
-export declare type StartFlowParam = {
-    query: string;
-} | {
-    triggerId: string;
-    variables: Record<string, string>;
-};
+declare const SignalWithReportIdSchema: z.ZodObject<{
+    rule: z.ZodString;
+    metric: z.ZodString;
+    trigger: z.ZodString;
+    implementation: z.ZodString;
+} & {
+    reportId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    rule: string;
+    metric: string;
+    trigger: string;
+    implementation: string;
+    reportId: number;
+}, {
+    rule: string;
+    metric: string;
+    trigger: string;
+    implementation: string;
+    reportId: number;
+}>;
 
 /**
  * Token storage keys
@@ -3461,4 +4262,18 @@ declare type ToRemove = Simplify<{
     header: "sp-access-token";
 }>;
 
+declare type UiTool = InferUITool<Tool<z.infer<typeof inputSchema>, z.infer<typeof redactedOutputSchema>>>;
+
+declare type UiTool_2 = InferUITool<Tool<z.infer<typeof inputSchema_2>, z.infer<typeof redactedOutputSchema_2>>>;
+
+declare type UiTool_3 = InferUITool<Tool<z.infer<typeof inputSchema_3>, z.infer<typeof RedactedThinkResponse>>>;
+
+declare type UiTool_4 = InferUITool<Tool<z.infer<typeof inputSchema_4>, z.infer<typeof redactedOutputSchema_3>>>;
+
+declare type UiTool_5 = InferUITool<Tool<z.infer<typeof inputSchema_5>, z.infer<typeof redactedOutputSchema_4>>>;
+
+declare type UiTool_6 = InferUITool<Tool<z.infer<typeof inputSchema_6>, z.infer<typeof redactedOutputSchema_5>>>;
+
+declare type UiTool_7 = InferUITool<Tool<z.infer<typeof inputSchema_7>, z.infer<typeof redactedOutputSchema_6>>>;
+
 export { }