@magemetrics/core 0.6.1 → 0.8.1

package/dist/index.d.ts

@@ -491,6 +491,18 @@ declare const inputSchema_7: z.ZodObject<{
     query: z.ZodString;
 }, z.core.$strip>;
 
+declare const inputSchema_8: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        multiSelect: z.ZodBoolean;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
 declare type InternalApiClient = Simplify<Client<NoAuthPaths, `${string}/${string}`>>;
 
 export declare class MageMetricsChatTransport extends DefaultChatTransport<MMChatUIMessage> {
@@ -788,6 +800,7 @@ declare type MMUiTools = {
     getAvailableTables: UiTool_5;
     getAvailableColumnsForTable: UiTool_6;
     webSearch: UiTool_7;
+    askUserQuestion: UiTool_8;
 };
 
 declare type NoAuthPaths = Simplify<{
@@ -1599,6 +1612,85 @@ declare interface operations {
             };
         };
     };
+    getColumnLineage: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The report id */
+                    report_id: number;
+                    /** @description The column name to get lineage for */
+                    column_name: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Column lineage data */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        column_name: string;
+                        lineage: {
+                            nodes: {
+                                id: string;
+                                /** @enum {string} */
+                                type: "entity" | "attribute" | "filter" | "process" | "combine" | "result";
+                                explanation: string;
+                            }[];
+                            edges: {
+                                source: string;
+                                target: string;
+                            }[];
+                        };
+                        was_cached: boolean;
+                    };
+                };
+            };
+            /** @description Invalid request - column not found in query results */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description report not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Generation failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
     toggleBookmark: {
         parameters: {
             query?: never;
@@ -3083,6 +3175,79 @@ declare interface operations {
             };
         };
     };
+    tablePreview: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                tableId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Table preview executed successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        columns: {
+                            id: string;
+                            accessorKey: string;
+                            header: string;
+                            cell?: unknown;
+                            meta?: {
+                                [key: string]: unknown;
+                            };
+                        }[];
+                        data: {
+                            [key: string]: unknown;
+                        }[];
+                        metadata?: {
+                            wasSampled: boolean;
+                            originalCount: number;
+                            sampledCount: number;
+                        };
+                    };
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Table not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
     listSankeyUserFilters: {
         parameters: {
             query?: never;
@@ -3902,6 +4067,22 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/workflows/column_lineage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["getColumnLineage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/timeline/bookmark": {
         parameters: {
             query?: never;
@@ -4302,6 +4483,22 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/admin-console/tables/{tableId}/preview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["tablePreview"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/admin-console/usage-insights/filters": {
         parameters: {
             query?: never;
@@ -4455,6 +4652,17 @@ declare const QuickActionsSchema: z.ZodArray<z.ZodObject<{
     explanation: z.ZodString;
 }, z.core.$strip>>;
 
+declare const RedactedAskUserQuestionResponse: z.ZodObject<{
+    tool: z.ZodDefault<z.ZodLiteral<"askUserQuestion">>;
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"success">;
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strip>;
+
 declare const redactedOutputSchema: z.ZodObject<{
     tool: z.ZodLiteral<"generateDataReport">;
     result: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -4612,6 +4820,8 @@ declare type UiTool_6 = InferUITool<Tool<z.infer<typeof inputSchema_6>, z.infer<
 
 declare type UiTool_7 = InferUITool<Tool<z.infer<typeof inputSchema_7>, z.infer<typeof redactedOutputSchema_6>>>;
 
+declare type UiTool_8 = InferUITool<Tool<z.infer<typeof inputSchema_8>, z.infer<typeof RedactedAskUserQuestionResponse>>>;
+
 declare const UpdateCanvasSchema: z.ZodObject<{
     id: z.ZodUUID;
     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/index.js

@@ -57,7 +57,7 @@ var addApiKeyHeader = (apiKey) => {
 
 // package.json
 var package_default = {
-  version: "0.6.1"};
+  version: "0.8.1"};
 
 // src/core/MageMetricsEventEmitter.ts
 var MageMetricsEventEmitter = class {
@@ -151,7 +151,7 @@ var hashString = (value) => {
   return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
 
-// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.1.0_zod@4.1.13/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
+// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.1.0_zod@4.2.1/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
 function __rest(s, e) {
   var t = {};
   for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -468,6 +468,8 @@ function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
     options: metadataOrOptions
   };
 }
+
+// ../../node_modules/.pnpm/hono@4.11.1/node_modules/hono/dist/router/reg-exp-router/node.js
 new Set(".\\+*[^]$()");
 var createRoute = (routeConfig) => {
   const route = {
@@ -1594,6 +1596,85 @@ createRoute({
     }
   }
 });
+var ColumnLineageNodeSchema = z.object({
+  id: z.string(),
+  type: z.enum([
+    "entity",
+    "attribute",
+    "filter",
+    "process",
+    "combine",
+    "result"
+  ]),
+  explanation: z.string()
+});
+var ColumnLineageEdgeSchema = z.object({
+  source: z.string(),
+  target: z.string()
+});
+var ColumnLineageResponseSchema = z.object({
+  column_name: z.string(),
+  lineage: z.object({
+    nodes: z.array(ColumnLineageNodeSchema),
+    edges: z.array(ColumnLineageEdgeSchema)
+  }),
+  was_cached: z.boolean()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/workflows/column_lineage",
+  operationId: "getColumnLineage",
+  request: {
+    headers: SupabaseHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            report_id: z.number().int().describe("The report id"),
+            column_name: z.string().describe("The column name to get lineage for")
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Column lineage data",
+      content: {
+        "application/json": {
+          schema: ColumnLineageResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Invalid request - column not found in query results",
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      }
+    },
+    404: {
+      description: "report not found",
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      }
+    },
+    500: {
+      description: "Generation failed",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
 createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}",
@@ -3130,13 +3211,28 @@ var toSearchParams = ({ cursor, filters, sorting, limit }) => {
   }
   return params;
 };
+var isToolResultMessage = (message) => {
+  if (message.role !== "assistant") {
+    return false;
+  }
+  return message.parts.some(
+    (part) => part.type.startsWith("tool-") && "state" in part && part.state === "output-available"
+  );
+};
 var MageMetricsChatTransport = class extends DefaultChatTransport {
   constructor(apiUrl, flowId, options) {
     super({
       ...options,
       api: `${apiUrl}/api/v1/chat/${flowId}`,
       prepareSendMessagesRequest({ messages, id: chatId }) {
-        return { body: { message: messages.at(-1), id: chatId } };
+        const lastMessage = messages.at(-1);
+        if (lastMessage && isToolResultMessage(lastMessage)) {
+          lastMessage.metadata = {
+            ...typeof lastMessage.metadata === "object" ? lastMessage.metadata : void 0,
+            isFrontendToolSubmission: true
+          };
+        }
+        return { body: { message: lastMessage, id: chatId } };
       }
     });
   }