@owox/backend 0.35.0 → 0.36.0

package/dist/src/ee/mcp/tools/query-data-mart.tool.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod-v4';
 import type { McpScope } from '@owox/idp-protocol';
 import { type McpDataMartsFacade } from '../../../data-marts/facades/mcp-data-marts.facade';
 import { ClsContextService } from '../../../common/logger/cls-context.service';
@@ -14,174 +14,104 @@ export declare class QueryDataMartTool implements McpToolDefinition<QueryDataMar
     readonly description: string;
     readonly zodSchema: {
         data_mart_id: z.ZodString;
-        fields: z.ZodArray<z.ZodString, "many">;
+        fields: z.ZodArray<z.ZodString>;
         slices: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            operator: z.ZodEffects<z.ZodCatch<z.ZodEnum<["between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", ...("between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after")[]]>>, "between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown>;
-            value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
-        }, "strip", z.ZodTypeAny, {
-            operator: "between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after";
-            field: string;
-            value?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
-        }, {
-            field: string;
-            value?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
-            operator?: unknown;
-        }>, "many">>;
+            operator: z.ZodType<"between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown, z.core.$ZodTypeInternals<"between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
+        }, z.core.$strip>>>;
         filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            operator: z.ZodEffects<z.ZodCatch<z.ZodEnum<["between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", ...("between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after")[]]>>, "between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown>;
-            value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
-        }, "strip", z.ZodTypeAny, {
-            operator: "between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after";
-            field: string;
-            value?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
-        }, {
-            field: string;
-            value?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
-            operator?: unknown;
-        }>, "many">>;
+            operator: z.ZodType<"between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown, z.core.$ZodTypeInternals<"between" | "in" | "this_week" | "last_week" | "this_month" | "this_quarter" | "last_quarter" | "this_year" | "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "gt" | "lt" | "gte" | "lte" | "is_blank" | "is_not_blank" | "is_empty" | "is_not_empty" | "is_null" | "is_not_null" | "not_in" | "in_last_n_days" | "in_next_n_days" | "before" | "after", unknown>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
+        }, z.core.$strip>>>;
         aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            function: z.ZodEnum<["SUM", "COUNT", "COUNT_DISTINCT", "AVG", "MIN", "MAX", "P25", "P50", "P75", "P95"]>;
-        }, "strip", z.ZodTypeAny, {
-            function: "MAX" | "MIN" | "SUM" | "AVG" | "COUNT" | "COUNT_DISTINCT" | "P25" | "P50" | "P75" | "P95";
-            field: string;
-        }, {
-            function: "MAX" | "MIN" | "SUM" | "AVG" | "COUNT" | "COUNT_DISTINCT" | "P25" | "P50" | "P75" | "P95";
-            field: string;
-        }>, "many">>;
+            function: z.ZodEnum<{
+                MAX: "MAX";
+                MIN: "MIN";
+                SUM: "SUM";
+                AVG: "AVG";
+                COUNT: "COUNT";
+                COUNT_DISTINCT: "COUNT_DISTINCT";
+                P25: "P25";
+                P50: "P50";
+                P75: "P75";
+                P95: "P95";
+            }>;
+        }, z.core.$strip>>>;
         date_buckets: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            unit: z.ZodEnum<["DAY", "WEEK", "MONTH", "QUARTER", "YEAR"]>;
+            unit: z.ZodEnum<{
+                DAY: "DAY";
+                WEEK: "WEEK";
+                MONTH: "MONTH";
+                QUARTER: "QUARTER";
+                YEAR: "YEAR";
+            }>;
             time_zone: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            unit: "DAY" | "WEEK" | "MONTH" | "QUARTER" | "YEAR";
-            field: string;
-            time_zone?: string | undefined;
-        }, {
-            unit: "DAY" | "WEEK" | "MONTH" | "QUARTER" | "YEAR";
-            field: string;
-            time_zone?: string | undefined;
-        }>, "many">>;
+        }, z.core.$strip>>>;
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            direction: z.ZodEnum<["asc", "desc"]>;
-        }, "strip", z.ZodTypeAny, {
-            direction: "asc" | "desc";
-            field: string;
-        }, {
-            direction: "asc" | "desc";
-            field: string;
-        }>, "many">>;
+            direction: z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>;
+        }, z.core.$strip>>>;
         limit: z.ZodOptional<z.ZodNumber>;
     };
     readonly outputSchema: {
-        columns: z.ZodArray<z.ZodString, "many">;
+        columns: z.ZodArray<z.ZodString>;
         column_metadata: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             display_name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             type: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            display_name: string;
-            type?: string | undefined;
-            description?: string | undefined;
-        }, {
-            name: string;
-            display_name: string;
-            type?: string | undefined;
-            description?: string | undefined;
-        }>, "many">;
+        }, z.core.$strip>>;
         rows: z.ZodString;
         returned_rows: z.ZodNumber;
         truncated: z.ZodBoolean;
         truncation: z.ZodOptional<z.ZodObject<{
-            reasons: z.ZodArray<z.ZodEnum<["row_limit", "payload_byte_cap"]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            reasons: ("row_limit" | "payload_byte_cap")[];
-        }, {
-            reasons: ("row_limit" | "payload_byte_cap")[];
-        }>>;
+            reasons: z.ZodArray<z.ZodEnum<{
+                row_limit: "row_limit";
+                payload_byte_cap: "payload_byte_cap";
+            }>>;
+        }, z.core.$strip>>;
         totals: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         data_last_updated: z.ZodObject<{
             data_last_updated_at: z.ZodNullable<z.ZodString>;
             computed_at: z.ZodString;
-            coverage: z.ZodEnum<["complete", "partial", "unavailable"]>;
+            coverage: z.ZodEnum<{
+                partial: "partial";
+                complete: "complete";
+                unavailable: "unavailable";
+            }>;
             sources: z.ZodArray<z.ZodObject<{
                 table: z.ZodString;
                 data_last_updated_at: z.ZodNullable<z.ZodString>;
                 note: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                table: string;
-                data_last_updated_at: string | null;
-                note?: string | undefined;
-            }, {
-                table: string;
-                data_last_updated_at: string | null;
-                note?: string | undefined;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            sources: {
-                table: string;
-                data_last_updated_at: string | null;
-                note?: string | undefined;
-            }[];
-            coverage: "partial" | "complete" | "unavailable";
-            data_last_updated_at: string | null;
-            computed_at: string;
-        }, {
-            sources: {
-                table: string;
-                data_last_updated_at: string | null;
-                note?: string | undefined;
-            }[];
-            coverage: "partial" | "complete" | "unavailable";
-            data_last_updated_at: string | null;
-            computed_at: string;
-        }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         totals_error: z.ZodOptional<z.ZodString>;
         source: z.ZodObject<{
             data_mart: z.ZodObject<{
                 id: z.ZodString;
                 title: z.ZodString;
                 url: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                id: string;
-                title: string;
-                url: string;
-            }, {
-                id: string;
-                title: string;
-                url: string;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            data_mart: {
-                id: string;
-                title: string;
-                url: string;
-            };
-        }, {
-            data_mart: {
-                id: string;
-                title: string;
-                url: string;
-            };
-        }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
         calculation_origin: z.ZodObject<{
             rows: z.ZodLiteral<"taken_from_owox">;
-            totals: z.ZodEnum<["calculated_by_owox", "not_available", "failed"]>;
-            data_last_updated: z.ZodEnum<["measured_by_owox", "not_available"]>;
-        }, "strip", z.ZodTypeAny, {
-            totals: "failed" | "calculated_by_owox" | "not_available";
-            rows: "taken_from_owox";
-            data_last_updated: "not_available" | "measured_by_owox";
-        }, {
-            totals: "failed" | "calculated_by_owox" | "not_available";
-            rows: "taken_from_owox";
-            data_last_updated: "not_available" | "measured_by_owox";
-        }>;
+            totals: z.ZodEnum<{
+                failed: "failed";
+                calculated_by_owox: "calculated_by_owox";
+                not_available: "not_available";
+            }>;
+            data_last_updated: z.ZodEnum<{
+                not_available: "not_available";
+                measured_by_owox: "measured_by_owox";
+            }>;
+        }, z.core.$strip>;
         _instruction: z.ZodString;
     };
     readonly annotations: {

package/dist/src/ee/mcp/tools/query-data-mart.tool.js

@@ -14,7 +14,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryDataMartTool = void 0;
 const common_1 = require("@nestjs/common");
-const zod_1 = require("zod");
+const zod_v4_1 = require("zod-v4");
 const mcp_data_marts_facade_1 = require("../../../data-marts/facades/mcp-data-marts.facade");
 const business_violation_exception_1 = require("../../../common/exceptions/business-violation.exception");
 const project_operation_blocked_exception_1 = require("../../../common/exceptions/project-operation-blocked.exception");
@@ -94,61 +94,61 @@ Using the results:
 If truncated is true, not all matching rows were returned: narrow the query (fewer fields, tighter slices/filters) or raise limit (up to 1000). Always use the source metadata in the response: name the Data Mart the answer came from, distinguish numbers calculated by OWOX from arithmetic you perform yourself, and clearly warn the user when rows were truncated.`;
     zodSchema = query_data_mart_input_1.queryDataMartInputSchema.shape;
     outputSchema = {
-        columns: zod_1.z.array(zod_1.z.string()).describe('Business-friendly result headers, in rows order.'),
-        column_metadata: zod_1.z.array(zod_1.z.object({
-            name: zod_1.z.string().describe('Exact output column name.'),
-            display_name: zod_1.z.string().describe('Business-friendly label for presentation.'),
-            description: zod_1.z.string().optional(),
-            type: zod_1.z.string().optional(),
+        columns: zod_v4_1.z.array(zod_v4_1.z.string()).describe('Business-friendly result headers, in rows order.'),
+        column_metadata: zod_v4_1.z.array(zod_v4_1.z.object({
+            name: zod_v4_1.z.string().describe('Exact output column name.'),
+            display_name: zod_v4_1.z.string().describe('Business-friendly label for presentation.'),
+            description: zod_v4_1.z.string().optional(),
+            type: zod_v4_1.z.string().optional(),
         })),
-        rows: zod_1.z.string(),
-        returned_rows: zod_1.z.number(),
-        truncated: zod_1.z.boolean(),
-        truncation: zod_1.z
+        rows: zod_v4_1.z.string(),
+        returned_rows: zod_v4_1.z.number(),
+        truncated: zod_v4_1.z.boolean(),
+        truncation: zod_v4_1.z
             .object({
-            reasons: zod_1.z.array(zod_1.z.enum(['row_limit', 'payload_byte_cap'])).min(1),
+            reasons: zod_v4_1.z.array(zod_v4_1.z.enum(['row_limit', 'payload_byte_cap'])).min(1),
         })
             .optional(),
-        totals: zod_1.z
-            .record(zod_1.z.string(), zod_1.z.unknown())
+        totals: zod_v4_1.z
+            .record(zod_v4_1.z.string(), zod_v4_1.z.unknown())
             .nullable()
             .describe('Server-side totals keyed by technical output column name. Match each key to column_metadata[].name.'),
-        data_last_updated: zod_1.z.object({
-            data_last_updated_at: zod_1.z
+        data_last_updated: zod_v4_1.z.object({
+            data_last_updated_at: zod_v4_1.z
                 .string()
                 .nullable()
                 .describe('When the SOURCE TABLES last changed in the warehouse (ISO-8601 UTC), not a claim about which period the data covers. null = the warehouse does not report it; treat as unknown, never as stale or fresh.'),
-            computed_at: zod_1.z
+            computed_at: zod_v4_1.z
                 .string()
                 .describe('When this was measured. Computed live for this query; never cached.'),
-            coverage: zod_1.z
+            coverage: zod_v4_1.z
                 .enum(['complete', 'partial', 'unavailable'])
                 .describe('complete = every source table resolved. partial = some could not be read, so the true time is at least as recent as reported. unavailable = nothing could be determined.'),
-            sources: zod_1.z
-                .array(zod_1.z.object({
-                table: zod_1.z.string(),
-                data_last_updated_at: zod_1.z.string().nullable(),
-                note: zod_1.z.string().optional(),
+            sources: zod_v4_1.z
+                .array(zod_v4_1.z.object({
+                table: zod_v4_1.z.string(),
+                data_last_updated_at: zod_v4_1.z.string().nullable(),
+                note: zod_v4_1.z.string().optional(),
             }))
                 .describe('Per-table detail behind the value. Views are excluded deliberately.'),
         }),
-        totals_error: zod_1.z
+        totals_error: zod_v4_1.z
             .string()
             .optional()
             .describe('Present only when totals were requested but FAILED. Totals are null in that case for a reason, not because the report has none — do not substitute a total summed from the returned rows.'),
-        source: zod_1.z.object({
-            data_mart: zod_1.z.object({
-                id: zod_1.z.string(),
-                title: zod_1.z.string(),
-                url: zod_1.z.string(),
+        source: zod_v4_1.z.object({
+            data_mart: zod_v4_1.z.object({
+                id: zod_v4_1.z.string(),
+                title: zod_v4_1.z.string(),
+                url: zod_v4_1.z.string(),
             }),
         }),
-        calculation_origin: zod_1.z.object({
-            rows: zod_1.z.literal('taken_from_owox'),
-            totals: zod_1.z.enum(['calculated_by_owox', 'not_available', 'failed']),
-            data_last_updated: zod_1.z.enum(['measured_by_owox', 'not_available']),
+        calculation_origin: zod_v4_1.z.object({
+            rows: zod_v4_1.z.literal('taken_from_owox'),
+            totals: zod_v4_1.z.enum(['calculated_by_owox', 'not_available', 'failed']),
+            data_last_updated: zod_v4_1.z.enum(['measured_by_owox', 'not_available']),
         }),
-        _instruction: zod_1.z.string(),
+        _instruction: zod_v4_1.z.string(),
     };
     annotations = {
         title: 'Query Data Mart',
@@ -295,7 +295,7 @@ If truncated is true, not all matching rows were returned: narrow the query (few
         }
     }
     mapError(err) {
-        if (err instanceof zod_1.z.ZodError) {
+        if (err instanceof zod_v4_1.z.ZodError) {
             const detail = err.issues
                 .map(i => (i.path.length ? `${i.path.join('.')}: ${i.message}` : i.message))
                 .join('; ');

package/dist/src/ee/mcp/tools/report-output-controls-output.d.ts

@@ -1,86 +1,43 @@
-import { z } from 'zod';
+import { z } from 'zod-v4';
 export declare const reportOutputControlsOutputShape: {
-    fields: z.ZodArray<z.ZodString, "many">;
-    unique_count_sources: z.ZodArray<z.ZodString, "many">;
+    fields: z.ZodArray<z.ZodString>;
+    unique_count_sources: z.ZodArray<z.ZodString>;
     filters: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         operator: z.ZodString;
         value: z.ZodOptional<z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        operator: string;
-        field: string;
-        value?: unknown;
-    }, {
-        operator: string;
-        field: string;
-        value?: unknown;
-    }>, "many">;
+    }, z.core.$strip>>;
     slices: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         operator: z.ZodString;
         value: z.ZodOptional<z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        operator: string;
-        field: string;
-        value?: unknown;
-    }, {
-        operator: string;
-        field: string;
-        value?: unknown;
-    }>, "many">;
+    }, z.core.$strip>>;
     ui_only_filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         operator: z.ZodString;
         value: z.ZodOptional<z.ZodUnknown>;
-    } & {
-        placement: z.ZodEnum<["pre-join", "post-join"]>;
+        placement: z.ZodEnum<{
+            "pre-join": "pre-join";
+            "post-join": "post-join";
+        }>;
         function: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        operator: string;
-        placement: "pre-join" | "post-join";
-        field: string;
-        function?: string | undefined;
-        value?: unknown;
-    }, {
-        operator: string;
-        placement: "pre-join" | "post-join";
-        field: string;
-        function?: string | undefined;
-        value?: unknown;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     aggregations: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         function: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        function: string;
-        field: string;
-    }, {
-        function: string;
-        field: string;
-    }>, "many">;
+    }, z.core.$strip>>;
     date_buckets: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         unit: z.ZodString;
         time_zone: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        unit: string;
-        field: string;
-        time_zone?: string | undefined;
-    }, {
-        unit: string;
-        field: string;
-        time_zone?: string | undefined;
-    }>, "many">;
+    }, z.core.$strip>>;
     sort: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
-        direction: z.ZodEnum<["asc", "desc"]>;
-    }, "strip", z.ZodTypeAny, {
-        direction: "asc" | "desc";
-        field: string;
-    }, {
-        direction: "asc" | "desc";
-        field: string;
-    }>, "many">;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
     limit: z.ZodNullable<z.ZodNumber>;
 };
 export declare const reportSheetInfoOutputShape: {

package/dist/src/ee/mcp/tools/report-output-controls-output.js

@@ -1,45 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reportSheetInfoOutputShape = exports.reportOutputControlsOutputShape = void 0;
-const zod_1 = require("zod");
-const filterOutputSchema = () => zod_1.z.object({
-    field: zod_1.z.string(),
-    operator: zod_1.z.string().describe('query_data_mart operator vocabulary.'),
-    value: zod_1.z.unknown().optional(),
+const zod_v4_1 = require("zod-v4");
+const filterOutputSchema = () => zod_v4_1.z.object({
+    field: zod_v4_1.z.string(),
+    operator: zod_v4_1.z.string().describe('query_data_mart operator vocabulary.'),
+    value: zod_v4_1.z.unknown().optional(),
 });
 exports.reportOutputControlsOutputShape = {
-    fields: zod_1.z
-        .array(zod_1.z.string())
+    fields: zod_v4_1.z
+        .array(zod_v4_1.z.string())
         .describe("Column names the report exports, or ['*'] when it exports every field. [] is a metrics-only report: no dimension column, only its Unique Count metric(s)."),
-    unique_count_sources: zod_1.z
-        .array(zod_1.z.string())
+    unique_count_sources: zod_v4_1.z
+        .array(zod_v4_1.z.string())
         .describe("Unique Count metrics the report carries: 'unique_count' for its own data mart, '<source>__unique_count' for joined sources (the names get_data_mart_details_by_id lists). Set only in the OWOX UI; update_report keeps them."),
-    filters: zod_1.z
+    filters: zod_v4_1.z
         .array(filterOutputSchema())
         .describe('Row filters applied on every run that update_report "filters" can replace, in add_report/update_report vocabulary.'),
-    slices: zod_1.z
+    slices: zod_v4_1.z
         .array(filterOutputSchema())
         .describe('Pre-join filters of a blended report that update_report "slices" can replace; empty for non-blended reports.'),
-    ui_only_filters: zod_1.z
+    ui_only_filters: zod_v4_1.z
         .array(filterOutputSchema().extend({
-        placement: zod_1.z.enum(['pre-join', 'post-join']),
-        function: zod_1.z
+        placement: zod_v4_1.z.enum(['pre-join', 'post-join']),
+        function: zod_v4_1.z
             .string()
             .optional()
             .describe('Set for a post-aggregation (HAVING) rule: the aggregate it constrains.'),
     }))
         .optional()
         .describe('Present only when the report also applies rules created in the OWOX UI that MCP cannot express (post-aggregation constraints, regex, calendar presets such as today or last month). update_report keeps them untouched whatever you send in filters/slices; they are changed or removed in the OWOX UI. Returned as stored — never re-send them.'),
-    aggregations: zod_1.z.array(zod_1.z.object({ field: zod_1.z.string(), function: zod_1.z.string() })),
-    date_buckets: zod_1.z.array(zod_1.z.object({ field: zod_1.z.string(), unit: zod_1.z.string(), time_zone: zod_1.z.string().optional() })),
-    sort: zod_1.z.array(zod_1.z.object({ field: zod_1.z.string(), direction: zod_1.z.enum(['asc', 'desc']) })),
-    limit: zod_1.z.number().nullable().describe('Max rows per run, or null when uncapped.'),
+    aggregations: zod_v4_1.z.array(zod_v4_1.z.object({ field: zod_v4_1.z.string(), function: zod_v4_1.z.string() })),
+    date_buckets: zod_v4_1.z.array(zod_v4_1.z.object({ field: zod_v4_1.z.string(), unit: zod_v4_1.z.string(), time_zone: zod_v4_1.z.string().optional() })),
+    sort: zod_v4_1.z.array(zod_v4_1.z.object({ field: zod_v4_1.z.string(), direction: zod_v4_1.z.enum(['asc', 'desc']) })),
+    limit: zod_v4_1.z.number().nullable().describe('Max rows per run, or null when uncapped.'),
 };
 exports.reportSheetInfoOutputShape = {
-    spreadsheet_id: zod_1.z
+    spreadsheet_id: zod_v4_1.z
         .string()
         .optional()
         .describe('Google Sheets only. Id of the spreadsheet the report writes to — pass it as spreadsheet_id to add_report to put a related export into the same document.'),
-    sheet_url: zod_1.z.string().optional().describe("Google Sheets only. Link to the report's sheet."),
+    sheet_url: zod_v4_1.z.string().optional().describe("Google Sheets only. Link to the report's sheet."),
 };
 //# sourceMappingURL=report-output-controls-output.js.map

package/dist/src/ee/mcp/tools/report-run-outcome.d.ts

@@ -1,60 +1,24 @@
-import { z } from 'zod';
+import { z } from 'zod-v4';
 import type { McpReportRunOutcome } from '../../../data-marts/facades/mcp-reports.facade';
-export declare const reportRunOutcomeSchema: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+export declare const reportRunOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     status: z.ZodLiteral<"queued">;
     run_id: z.ZodString;
     should_poll: z.ZodLiteral<true>;
     message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    status: "queued";
-    message: string;
-    run_id: string;
-    should_poll: true;
-}, {
-    status: "queued";
-    message: string;
-    run_id: string;
-    should_poll: true;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"not_requested">;
     should_poll: z.ZodLiteral<false>;
     message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    status: "not_requested";
-    message: string;
-    should_poll: false;
-}, {
-    status: "not_requested";
-    message: string;
-    should_poll: false;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"not_applicable">;
     should_poll: z.ZodLiteral<false>;
     message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    status: "not_applicable";
-    message: string;
-    should_poll: false;
-}, {
-    status: "not_applicable";
-    message: string;
-    should_poll: false;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"failed_to_queue">;
     should_poll: z.ZodLiteral<false>;
     error: z.ZodString;
     message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    status: "failed_to_queue";
-    message: string;
-    error: string;
-    should_poll: false;
-}, {
-    status: "failed_to_queue";
-    message: string;
-    error: string;
-    should_poll: false;
-}>]>;
+}, z.core.$strip>], "status">;
 export type ReportRunOutcomeOutput = z.infer<typeof reportRunOutcomeSchema>;
 export interface ReportRunOutcomeMessages {
     queued: string;