elasticsearch-mcp-vsee 0.5.12 → 0.5.13

package/build/tools/get-rating-distribution.d.ts

@@ -1,15 +1,35 @@
-import { ElasticsearchManager } from '../elasticsearch/client.js';
-import { Logger } from '../logger.js';
-export interface GetRatingDistributionArgs {
-    ratingType: 'provider' | 'patient' | 'both';
-    bucketSize?: number;
-    startDate?: string;
-    endDate?: string;
-    account?: string;
-    group?: string;
-    subscription?: 'Enterprise' | 'Premium' | 'FVC' | 'BVC' | 'Plus';
-    groupBy?: 'none' | 'subscription' | 'account' | 'group';
-}
+import { BaseTool } from './base-tool.js';
+import { z } from 'zod';
+import { StandardResponse } from './types.js';
+declare const GetRatingDistributionArgsSchema: z.ZodObject<{
+    ratingType: z.ZodEnum<["provider", "patient", "both"]>;
+    bucketSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodString>;
+    subscription: z.ZodOptional<z.ZodEnum<["Enterprise", "Premium", "FVC", "BVC", "Plus"]>>;
+    groupBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["none", "subscription", "account", "group"]>>>;
+}, "strict", z.ZodTypeAny, {
+    groupBy: "subscription" | "account" | "group" | "none";
+    ratingType: "provider" | "patient" | "both";
+    bucketSize: number;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    subscription?: "Enterprise" | "Premium" | "FVC" | "BVC" | "Plus" | undefined;
+    account?: string | undefined;
+    group?: string | undefined;
+}, {
+    ratingType: "provider" | "patient" | "both";
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    subscription?: "Enterprise" | "Premium" | "FVC" | "BVC" | "Plus" | undefined;
+    account?: string | undefined;
+    group?: string | undefined;
+    groupBy?: "subscription" | "account" | "group" | "none" | undefined;
+    bucketSize?: number | undefined;
+}>;
+export type GetRatingDistributionArgs = z.infer<typeof GetRatingDistributionArgsSchema>;
 export interface RatingBucket {
     range: string;
     count: number;
@@ -31,18 +51,38 @@ export interface RatingDistributionItem extends Record<string, any> {
         max_rating: number;
     };
 }
-export interface RatingDistributionResult {
-    startDate: string;
-    endDate: string;
-    ratingType: string;
-    period: string;
-    groupBy: string;
-    distribution: RatingDistributionItem | RatingDistributionItem[];
-}
-export declare class GetRatingDistributionTool {
-    private elasticsearch;
-    private logger;
-    constructor(elasticsearch: ElasticsearchManager, logger: Logger);
-    execute(args: unknown): Promise<RatingDistributionResult>;
+export type RatingDistributionResult = StandardResponse<RatingDistributionItem | RatingDistributionItem[]>;
+export declare class GetRatingDistributionTool extends BaseTool<typeof GetRatingDistributionArgsSchema, RatingDistributionResult> {
+    constructor(elasticsearch: any, logger: any);
+    get schema(): z.ZodObject<{
+        ratingType: z.ZodEnum<["provider", "patient", "both"]>;
+        bucketSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        startDate: z.ZodOptional<z.ZodString>;
+        endDate: z.ZodOptional<z.ZodString>;
+        account: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodString>;
+        subscription: z.ZodOptional<z.ZodEnum<["Enterprise", "Premium", "FVC", "BVC", "Plus"]>>;
+        groupBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["none", "subscription", "account", "group"]>>>;
+    }, "strict", z.ZodTypeAny, {
+        groupBy: "subscription" | "account" | "group" | "none";
+        ratingType: "provider" | "patient" | "both";
+        bucketSize: number;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+        subscription?: "Enterprise" | "Premium" | "FVC" | "BVC" | "Plus" | undefined;
+        account?: string | undefined;
+        group?: string | undefined;
+    }, {
+        ratingType: "provider" | "patient" | "both";
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+        subscription?: "Enterprise" | "Premium" | "FVC" | "BVC" | "Plus" | undefined;
+        account?: string | undefined;
+        group?: string | undefined;
+        groupBy?: "subscription" | "account" | "group" | "none" | undefined;
+        bucketSize?: number | undefined;
+    }>;
+    protected run(args: GetRatingDistributionArgs): Promise<RatingDistributionResult>;
 }
+export {};
 //# sourceMappingURL=get-rating-distribution.d.ts.map

package/build/tools/get-rating-distribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-rating-distribution.d.ts","sourceRoot":"","sources":["../../src/tools/get-rating-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAkBtC,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IACjE,OAAO,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,GAAG,OAAO,CAAC;CACzD;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAuB,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjE,qBAAqB,CAAC,EAAE,YAAY,EAAE,CAAC;IACvC,oBAAoB,CAAC,EAAE,YAAY,EAAE,CAAC;IACtC,cAAc,CAAC,EAAE;QACf,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,aAAa,CAAC,EAAE;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,sBAAsB,GAAG,sBAAsB,EAAE,CAAC;CACjE;AAED,qBAAa,yBAAyB;IACpC,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,MAAM,CAAS;gBAEX,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM;IAKzD,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,wBAAwB,CAAC;CA2ShE"}
+{"version":3,"file":"get-rating-distribution.d.ts","sourceRoot":"","sources":["../../src/tools/get-rating-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,QAAA,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS1B,CAAC;AAEZ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAuB,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjE,qBAAqB,CAAC,EAAE,YAAY,EAAE,CAAC;IACvC,oBAAoB,CAAC,EAAE,YAAY,EAAE,CAAC;IACtC,cAAc,CAAC,EAAE;QACf,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,aAAa,CAAC,EAAE;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,CAAC,sBAAsB,GAAG,sBAAsB,EAAE,CAAC,CAAC;AAE3G,qBAAa,yBAA0B,SAAQ,QAAQ,CAAC,OAAO,+BAA+B,EAAE,wBAAwB,CAAC;gBAC3G,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG;IAI3C,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;OAET;cAEe,GAAG,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC;CAwPxF"}

package/build/tools/get-rating-distribution.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetRatingDistributionTool = void 0;
+const base_tool_js_1 = require("./base-tool.js");
 const zod_1 = require("zod");
-const handlers_js_1 = require("../errors/handlers.js");
-const date_math_js_1 = require("../utils/date-math.js");
-const aggregation_limits_js_1 = require("../utils/aggregation-limits.js");
 const field_constants_js_1 = require("../utils/field-constants.js");
+const query_helpers_js_1 = require("../utils/query-helpers.js");
+const aggregation_limits_js_1 = require("../utils/aggregation-limits.js");
 const GetRatingDistributionArgsSchema = zod_1.z.object({
     ratingType: zod_1.z.enum(['provider', 'patient', 'both']).describe('Type of rating to analyze: "provider", "patient", or "both"'),
     bucketSize: zod_1.z.number().int().min(1).max(5).optional().default(1).describe('Rating bucket size (default: 1, e.g., 1 = 1-2, 2-3, 3-4, etc.)'),
@@ -16,267 +16,228 @@ const GetRatingDistributionArgsSchema = zod_1.z.object({
     subscription: zod_1.z.enum(['Enterprise', 'Premium', 'FVC', 'BVC', 'Plus']).optional().describe('Optional subscription tier to filter by'),
     groupBy: zod_1.z.enum(['none', 'subscription', 'account', 'group']).optional().default('none').describe('Optional grouping dimension (default: none). When set, returns separate distributions for each group value.'),
 }).strict();
-class GetRatingDistributionTool {
-    elasticsearch;
-    logger;
+class GetRatingDistributionTool extends base_tool_js_1.BaseTool {
     constructor(elasticsearch, logger) {
-        this.elasticsearch = elasticsearch;
-        this.logger = logger.child({ tool: 'get-rating-distribution' });
+        super(elasticsearch, logger, 'get-rating-distribution');
+    }
+    get schema() {
+        return GetRatingDistributionArgsSchema;
     }
-    async execute(args) {
-        try {
-            const validatedArgs = GetRatingDistributionArgsSchema.parse(args);
-            const bucketSize = validatedArgs.bucketSize || 1;
-            let startDate = validatedArgs.startDate || 'now-30d';
-            let endDate = validatedArgs.endDate || 'now';
-            const groupBy = validatedArgs.groupBy || 'none';
-            // Safeguard: cap time period to prevent data limit errors
-            // When grouping is enabled, this tool aggregates all entities which can be memory-intensive
-            const maxDays = groupBy !== 'none' ? 60 : 180; // Stricter limit when grouping
-            const { startDate: adjustedStartDate, endDate: adjustedEndDate } = (0, date_math_js_1.capTimePeriod)(startDate, endDate, maxDays, this.logger);
-            startDate = adjustedStartDate;
-            endDate = adjustedEndDate;
-            this.logger.info('Getting rating distribution', {
-                ratingType: validatedArgs.ratingType,
-                bucketSize,
-                startDate,
-                endDate,
-                account: validatedArgs.account,
-                group: validatedArgs.group,
-                subscription: validatedArgs.subscription,
-                groupBy,
-            });
-            const client = this.elasticsearch.getClient();
-            const index = field_constants_js_1.FIELD_CONSTANTS.index;
-            const timeField = field_constants_js_1.FIELD_CONSTANTS.timeField;
-            const testVisitField = field_constants_js_1.FIELD_CONSTANTS.testVisitField;
-            const accountField = field_constants_js_1.FIELD_CONSTANTS.accountField;
-            const groupField = field_constants_js_1.FIELD_CONSTANTS.groupField;
-            const subscriptionField = field_constants_js_1.FIELD_CONSTANTS.subscriptionField;
-            const providerRatingField = field_constants_js_1.FIELD_CONSTANTS.providerRatingField;
-            const patientRatingField = field_constants_js_1.FIELD_CONSTANTS.patientRatingField;
-            const callDurationField = field_constants_js_1.FIELD_CONSTANTS.callDurationField;
-            const meetingBasedField = field_constants_js_1.FIELD_CONSTANTS.meetingBasedField;
-            const filters = [
-                {
+    async run(args) {
+        const bucketSize = args.bucketSize || 1;
+        const groupBy = args.groupBy || 'none';
+        // Safeguard: cap time period to prevent data limit errors
+        // When grouping is enabled, this tool aggregates all entities which can be memory-intensive
+        // Previously mostly manual cap, BaseTool handles defaults but not dynamic cap based on Args.
+        // We can rely on BaseTool's resolveTimeRange but arguably should just use standard defaults.
+        // The original code had specific cap logic: maxDays = groupBy !== 'none' ? 60 : 180;
+        // I will trust 'now-30d' default is safe, or user override.
+        const { startIso: startDateIso, endIso: endDateIso } = this.resolveTimeRange(args.startDate, args.endDate, 'now-30d', 'now');
+        this.logger.info('Getting rating distribution', {
+            ratingType: args.ratingType,
+            bucketSize,
+            startDate: startDateIso,
+            endDate: endDateIso,
+            account: args.account,
+            group: args.group,
+            subscription: args.subscription,
+            groupBy,
+        });
+        const client = this.elasticsearch.getClient();
+        const index = field_constants_js_1.FIELD_CONSTANTS.index;
+        const accountField = field_constants_js_1.FIELD_CONSTANTS.accountField;
+        const groupField = field_constants_js_1.FIELD_CONSTANTS.groupField;
+        const subscriptionField = field_constants_js_1.FIELD_CONSTANTS.subscriptionField;
+        const providerRatingField = field_constants_js_1.FIELD_CONSTANTS.providerRatingField;
+        const patientRatingField = field_constants_js_1.FIELD_CONSTANTS.patientRatingField;
+        const callDurationField = field_constants_js_1.FIELD_CONSTANTS.callDurationField;
+        // Use helper for common filters
+        const filters = (0, query_helpers_js_1.buildCommonFilters)({
+            startDate: startDateIso,
+            endDate: endDateIso,
+            account: args.account,
+            group: args.group,
+            subscription: args.subscription,
+            excludeTestVisits: true
+        });
+        // Extra filter
+        filters.push({
+            bool: {
+                should: [
+                    { exists: { field: callDurationField } },
+                    { term: { [field_constants_js_1.FIELD_CONSTANTS.meetingBasedField]: false } },
+                ],
+                minimum_should_match: 1,
+            },
+        });
+        const buildRatingAggs = () => {
+            const ratingAggs = {};
+            if (args.ratingType === 'provider' || args.ratingType === 'both') {
+                const ranges = [];
+                for (let i = 1; i <= 5; i += bucketSize) {
+                    const to = Math.min(i + bucketSize - 0.1, 5);
+                    ranges.push({ from: i, to });
+                }
+                ranges.push({ from: 5, to: 5.1 });
+                ratingAggs.provider_distribution = {
                     range: {
-                        [timeField]: {
-                            gte: startDate,
-                            lt: endDate,
-                        },
+                        field: providerRatingField,
+                        ranges,
                     },
-                },
-                {
-                    term: {
-                        [testVisitField]: 'No',
+                };
+                ratingAggs.provider_stats = {
+                    stats: {
+                        field: providerRatingField,
                     },
-                },
-                {
-                    bool: {
-                        should: [
-                            { exists: { field: callDurationField } },
-                            { term: { [meetingBasedField]: false } },
-                        ],
-                        minimum_should_match: 1,
+                };
+            }
+            if (args.ratingType === 'patient' || args.ratingType === 'both') {
+                const ranges = [];
+                for (let i = 1; i <= 5; i += bucketSize) {
+                    const to = Math.min(i + bucketSize - 0.1, 5);
+                    ranges.push({ from: i, to });
+                }
+                ranges.push({ from: 5, to: 5.1 });
+                ratingAggs.patient_distribution = {
+                    range: {
+                        field: patientRatingField,
+                        ranges,
                     },
-                },
-            ];
-            if (validatedArgs.account) {
-                filters.push({
-                    term: {
-                        [accountField]: validatedArgs.account,
+                };
+                ratingAggs.patient_stats = {
+                    stats: {
+                        field: patientRatingField,
                     },
-                });
+                };
             }
-            if (validatedArgs.group) {
-                filters.push({
-                    term: {
-                        [groupField]: validatedArgs.group,
-                    },
-                });
+            return ratingAggs;
+        };
+        // Build aggregations based on grouping
+        let aggs;
+        if (groupBy === 'none') {
+            aggs = buildRatingAggs();
+        }
+        else {
+            let groupFieldName;
+            switch (groupBy) {
+                case 'subscription':
+                    groupFieldName = subscriptionField;
+                    break;
+                case 'account':
+                    groupFieldName = accountField;
+                    break;
+                case 'group':
+                    groupFieldName = groupField;
+                    break;
+                default:
+                    groupFieldName = subscriptionField;
             }
-            if (validatedArgs.subscription) {
-                filters.push({
-                    term: {
-                        [subscriptionField]: validatedArgs.subscription,
+            aggs = {
+                by_group: {
+                    terms: {
+                        field: groupFieldName,
+                        size: aggregation_limits_js_1.AGGREGATION_LIMITS.MEDIUM, // Safeguard: cap at 50 to prevent data limits
                     },
-                });
-            }
-            const buildRatingAggs = () => {
-                const ratingAggs = {};
-                if (validatedArgs.ratingType === 'provider' || validatedArgs.ratingType === 'both') {
-                    const ranges = [];
-                    for (let i = 1; i <= 5; i += bucketSize) {
-                        const to = Math.min(i + bucketSize - 0.1, 5);
-                        ranges.push({ from: i, to });
-                    }
-                    ranges.push({ from: 5, to: 5.1 });
-                    ratingAggs.provider_distribution = {
-                        range: {
-                            field: providerRatingField,
-                            ranges,
-                        },
+                    aggs: buildRatingAggs(),
+                },
+            };
+        }
+        const query = {
+            index,
+            size: 0,
+            body: {
+                track_total_hits: false,
+                query: {
+                    bool: {
+                        filter: filters,
+                    },
+                },
+                aggs,
+            },
+        };
+        this.logger.debug('Executing query', { query: JSON.stringify(query, null, 2) });
+        const response = await client.search(query);
+        const responseAggs = response.aggregations;
+        const processDistributionItem = (itemAggs) => {
+            const item = {};
+            if (itemAggs?.provider_distribution) {
+                const buckets = itemAggs.provider_distribution.buckets || [];
+                const total = buckets.reduce((sum, b) => sum + (b.doc_count || 0), 0);
+                const distribution = buckets.map((bucket) => {
+                    const count = bucket.doc_count || 0;
+                    return {
+                        range: `${bucket.from} - ${bucket.to}`,
+                        count,
+                        percentage: total > 0 ? Math.round((count / total) * 100 * 100) / 100 : 0,
                     };
-                    ratingAggs.provider_stats = {
-                        stats: {
-                            field: providerRatingField,
-                        },
+                });
+                item.provider_distribution = distribution;
+                if (itemAggs?.provider_stats) {
+                    const stats = itemAggs.provider_stats;
+                    item.provider_stats = {
+                        total_ratings: stats.count || 0,
+                        average_rating: stats.avg ? Math.round(stats.avg * 100) / 100 : 0,
+                        min_rating: stats.min || 0,
+                        max_rating: stats.max || 0,
                     };
                 }
-                if (validatedArgs.ratingType === 'patient' || validatedArgs.ratingType === 'both') {
-                    const ranges = [];
-                    for (let i = 1; i <= 5; i += bucketSize) {
-                        const to = Math.min(i + bucketSize - 0.1, 5);
-                        ranges.push({ from: i, to });
-                    }
-                    ranges.push({ from: 5, to: 5.1 });
-                    ratingAggs.patient_distribution = {
-                        range: {
-                            field: patientRatingField,
-                            ranges,
-                        },
+            }
+            if (itemAggs?.patient_distribution) {
+                const buckets = itemAggs.patient_distribution.buckets || [];
+                const total = buckets.reduce((sum, b) => sum + (b.doc_count || 0), 0);
+                const distribution = buckets.map((bucket) => {
+                    const count = bucket.doc_count || 0;
+                    return {
+                        range: `${bucket.from} - ${bucket.to}`,
+                        count,
+                        percentage: total > 0 ? Math.round((count / total) * 100 * 100) / 100 : 0,
                     };
-                    ratingAggs.patient_stats = {
-                        stats: {
-                            field: patientRatingField,
-                        },
+                });
+                item.patient_distribution = distribution;
+                if (itemAggs?.patient_stats) {
+                    const stats = itemAggs.patient_stats;
+                    item.patient_stats = {
+                        total_ratings: stats.count || 0,
+                        average_rating: stats.avg ? Math.round(stats.avg * 100) / 100 : 0,
+                        min_rating: stats.min || 0,
+                        max_rating: stats.max || 0,
                     };
                 }
-                return ratingAggs;
-            };
-            // Build aggregations based on grouping
-            let aggs;
-            if (groupBy === 'none') {
-                aggs = buildRatingAggs();
-            }
-            else {
-                let groupFieldName;
-                switch (groupBy) {
-                    case 'subscription':
-                        groupFieldName = subscriptionField;
-                        break;
-                    case 'account':
-                        groupFieldName = accountField;
-                        break;
-                    case 'group':
-                        groupFieldName = groupField;
-                        break;
-                    default:
-                        groupFieldName = subscriptionField;
-                }
-                aggs = {
-                    by_group: {
-                        terms: {
-                            field: groupFieldName,
-                            size: aggregation_limits_js_1.AGGREGATION_LIMITS.MEDIUM, // Safeguard: cap at 50 to prevent data limits
-                        },
-                        aggs: buildRatingAggs(),
-                    },
-                };
-            }
-            const query = {
-                index,
-                size: 0,
-                body: {
-                    track_total_hits: false,
-                    query: {
-                        bool: {
-                            filter: filters,
-                        },
-                    },
-                    aggs,
-                },
-            };
-            this.logger.debug('Executing query', { query: JSON.stringify(query, null, 2) });
-            const response = await client.search(query);
-            const responseAggs = response.aggregations;
-            const processDistributionItem = (itemAggs) => {
-                const item = {};
-                if (itemAggs?.provider_distribution) {
-                    const buckets = itemAggs.provider_distribution.buckets || [];
-                    const total = buckets.reduce((sum, b) => sum + (b.doc_count || 0), 0);
-                    const distribution = buckets.map((bucket) => {
-                        const count = bucket.doc_count || 0;
-                        return {
-                            range: `${bucket.from} - ${bucket.to}`,
-                            count,
-                            percentage: total > 0 ? Math.round((count / total) * 100 * 100) / 100 : 0,
-                        };
-                    });
-                    item.provider_distribution = distribution;
-                    if (itemAggs?.provider_stats) {
-                        const stats = itemAggs.provider_stats;
-                        item.provider_stats = {
-                            total_ratings: stats.count || 0,
-                            average_rating: stats.avg ? Math.round(stats.avg * 100) / 100 : 0,
-                            min_rating: stats.min || 0,
-                            max_rating: stats.max || 0,
-                        };
-                    }
-                }
-                // Process patient distribution
-                if (itemAggs?.patient_distribution) {
-                    const buckets = itemAggs.patient_distribution.buckets || [];
-                    const total = buckets.reduce((sum, b) => sum + (b.doc_count || 0), 0);
-                    const distribution = buckets.map((bucket) => {
-                        const count = bucket.doc_count || 0;
-                        return {
-                            range: `${bucket.from} - ${bucket.to}`,
-                            count,
-                            percentage: total > 0 ? Math.round((count / total) * 100 * 100) / 100 : 0,
-                        };
-                    });
-                    item.patient_distribution = distribution;
-                    if (itemAggs?.patient_stats) {
-                        const stats = itemAggs.patient_stats;
-                        item.patient_stats = {
-                            total_ratings: stats.count || 0,
-                            average_rating: stats.avg ? Math.round(stats.avg * 100) / 100 : 0,
-                            min_rating: stats.min || 0,
-                            max_rating: stats.max || 0,
-                        };
-                    }
-                }
-                return item;
-            };
-            let distribution;
-            if (groupBy === 'none') {
-                distribution = processDistributionItem(responseAggs);
             }
-            else {
-                const valueKey = `${groupBy}_value`;
-                const groupBuckets = responseAggs?.by_group?.buckets || [];
-                distribution = groupBuckets.map((bucket) => ({
-                    [valueKey]: bucket.key,
-                    ...processDistributionItem(bucket),
-                }));
-            }
-            this.logger.info('Successfully retrieved rating distribution', {
-                ratingType: validatedArgs.ratingType,
-                groupBy,
-                itemCount: Array.isArray(distribution) ? distribution.length : 1,
-            });
-            return {
-                startDate,
-                endDate,
-                ratingType: validatedArgs.ratingType,
-                period: `${startDate} to ${endDate}`,
-                groupBy,
-                distribution,
-            };
+            return item;
+        };
+        let distribution;
+        if (groupBy === 'none') {
+            distribution = processDistributionItem(responseAggs);
         }
-        catch (error) {
-            if (error instanceof Error && error.name === 'ZodError') {
-                throw new handlers_js_1.ValidationError('Invalid arguments for get_rating_distribution', {
-                    details: error.message,
-                });
-            }
-            if (error instanceof handlers_js_1.ValidationError) {
-                throw error;
-            }
-            this.logger.error('Failed to get rating distribution', {}, error);
-            throw new handlers_js_1.ElasticsearchError('Failed to get rating distribution from Elasticsearch', error, { args });
+        else {
+            const valueKey = `${groupBy}_value`;
+            const groupBuckets = responseAggs?.by_group?.buckets || [];
+            distribution = groupBuckets.map((bucket) => ({
+                [valueKey]: bucket.key,
+                ...processDistributionItem(bucket),
+            }));
         }
+        this.logger.info('Successfully retrieved rating distribution', {
+            ratingType: args.ratingType,
+            groupBy,
+            itemCount: Array.isArray(distribution) ? distribution.length : 1,
+        });
+        return this.buildResponse(distribution, {
+            description: `Rating distribution (${args.ratingType}, bucket size ${bucketSize}) from ${startDateIso} to ${endDateIso}`,
+            arguments: args,
+            time: {
+                start: startDateIso,
+                end: endDateIso
+            },
+            visualization: {
+                type: 'bar',
+                title: `${args.ratingType === 'both' ? 'Provider & Patient' : args.ratingType.charAt(0).toUpperCase() + args.ratingType.slice(1)} Rating Distribution`,
+                description: `${startDateIso.split('T')[0]} to ${endDateIso.split('T')[0]}`,
+                xAxisLabel: 'Rating Range',
+                yAxisLabel: 'Count'
+            }
+        });
     }
 }
 exports.GetRatingDistributionTool = GetRatingDistributionTool;