@owox/backend 0.30.0 → 0.30.1

package/dist/src/ee/mcp/tools/list-report-run-schedules.tool.js

@@ -15,19 +15,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListReportRunSchedulesTool = void 0;
 const common_1 = require("@nestjs/common");
 const zod_1 = require("zod");
+const public_origin_service_1 = require("../../../common/config/public-origin.service");
 const mcp_scheduled_triggers_facade_1 = require("../../../data-marts/facades/mcp-scheduled-triggers.facade");
 const mcp_tool_definition_1 = require("./mcp-tool.definition");
+const data_mart_ui_path_1 = require("./data-mart-ui-path");
+const mcp_public_url_util_1 = require("./mcp-public-url.util");
 const inputSchema = zod_1.z.object({}).strict();
 let ListReportRunSchedulesTool = class ListReportRunSchedulesTool {
     facade;
+    publicOriginService;
     name = 'list_report_run_schedules';
     description = 'Lists every scheduled REPORT_RUN trigger (report run schedule) in the current OWOX project that the current MCP user can see, in a single response. Each item includes trigger_id — pass it to update_report_run_schedule to modify that specific schedule or delete_report_run_schedule to remove it — plus the report and data mart it belongs to. To add another schedule for a report, call create_report_run_schedule; creating never replaces existing schedules.';
     zodSchema = inputSchema.shape;
     outputSchema = {
         schedules: zod_1.z.array(zod_1.z.object({
             trigger_id: zod_1.z.string(),
-            report: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string() }),
-            data_mart: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string() }),
+            report: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string(), url: zod_1.z.string() }),
+            data_mart: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string(), url: zod_1.z.string() }),
+            schedules_url: zod_1.z.string().describe('Open report schedules in OWOX.'),
             cron_expression: zod_1.z.string(),
             time_zone: zod_1.z.string(),
             is_active: zod_1.z.boolean(),
@@ -44,8 +49,9 @@ let ListReportRunSchedulesTool = class ListReportRunSchedulesTool {
         openWorldHint: false,
     };
     requiredScopes = ['mcp:read'];
-    constructor(facade) {
+    constructor(facade, publicOriginService) {
         this.facade = facade;
+        this.publicOriginService = publicOriginService;
     }
     parseInput(input) {
         return inputSchema.parse(input);
@@ -54,11 +60,20 @@ let ListReportRunSchedulesTool = class ListReportRunSchedulesTool {
         this.parseInput(input);
         const ctx = { projectId: context.projectId, userId: context.userId, roles: context.roles };
         const items = await this.facade.listReportRunSchedules(ctx);
+        const publicOrigin = this.publicOriginService.getPublicOrigin();
+        const schedulesUrl = (0, mcp_public_url_util_1.joinPublicOrigin)(publicOrigin, (0, data_mart_ui_path_1.buildReportSchedulesUiPath)(context.projectId));
         const structuredContent = {
             schedules: items.map(item => ({
                 trigger_id: item.triggerId,
-                report: item.report,
-                data_mart: item.dataMart,
+                report: {
+                    ...item.report,
+                    url: (0, mcp_public_url_util_1.joinPublicOrigin)(publicOrigin, (0, data_mart_ui_path_1.buildReportsUiPath)(context.projectId, item.dataMart.id)),
+                },
+                data_mart: {
+                    ...item.dataMart,
+                    url: (0, mcp_public_url_util_1.joinPublicOrigin)(publicOrigin, (0, data_mart_ui_path_1.buildDataMartUiPath)(context.projectId, item.dataMart.id)),
+                },
+                schedules_url: schedulesUrl,
                 cron_expression: item.cronExpression,
                 time_zone: item.timeZone,
                 is_active: item.isActive,
@@ -75,6 +90,6 @@ exports.ListReportRunSchedulesTool = ListReportRunSchedulesTool;
 exports.ListReportRunSchedulesTool = ListReportRunSchedulesTool = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(mcp_scheduled_triggers_facade_1.MCP_SCHEDULED_TRIGGERS_FACADE)),
-    __metadata("design:paramtypes", [Object])
+    __metadata("design:paramtypes", [Object, public_origin_service_1.PublicOriginService])
 ], ListReportRunSchedulesTool);
 //# sourceMappingURL=list-report-run-schedules.tool.js.map

package/dist/src/ee/mcp/tools/mcp-project-summary.util.d.ts

@@ -0,0 +1,7 @@
+import type { McpProjectContextFacade } from '../../../idp/facades/mcp-project-context.facade';
+import type { McpAuthContext } from '../auth/mcp-auth-context';
+export interface McpProjectSummary {
+    id: string;
+    title: string;
+}
+export declare function tryGetMcpProjectSummary(projectContext: McpProjectContextFacade, context: McpAuthContext): Promise<McpProjectSummary | undefined>;

package/dist/src/ee/mcp/tools/mcp-project-summary.util.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryGetMcpProjectSummary = tryGetMcpProjectSummary;
+async function tryGetMcpProjectSummary(projectContext, context) {
+    try {
+        const result = await projectContext.getProjectContext({
+            projectId: context.projectId,
+            userId: context.userId,
+            roles: context.roles,
+        });
+        return { id: result.project.id, title: result.project.title };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=mcp-project-summary.util.js.map

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

@@ -2,14 +2,16 @@ import { z } from 'zod';
 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';
+import { PublicOriginService } from '../../../common/config/public-origin.service';
 import type { McpAuthContext } from '../auth/mcp-auth-context';
 import type { McpToolDefinition, McpToolResult } from './mcp-tool.definition';
 import { type QueryDataMartInput } from './query-data-mart.input';
 export declare class QueryDataMartTool implements McpToolDefinition<QueryDataMartInput> {
     private readonly dataMarts;
     private readonly cls;
+    private readonly publicOriginService;
     readonly name = "query_data_mart";
-    readonly description = "Query an OWOX data mart and return its data rows in a compact, header-once table, plus server-side totals computed over all matching rows (ignoring the row limit). Each call costs credits.\n\nCall get_data_mart_details_by_id first to get the data mart's exact field names and joinable/blended fields, then copy field names verbatim into fields \u2014 unless you already have that schema in context. Field names must be exact; never guess or invent them.\n\nWhen building the query:\n- Request only the fields relevant to the user's question \u2014 never request all fields.\n- Use limit to control how many rows come back (1\u20131000, default 20). There is no offset/pagination: the tool returns a bounded subset.\n- aggregations: SUM, COUNT, COUNT_DISTINCT, AVG, MIN, MAX, and percentiles P25/P50/P75/P95 \u2014 but each data mart's output controls decide which functions a given field allows, so some may be rejected (pick another, or ask an admin to enable it). Group-by is implied by the non-aggregated fields you select.\n- date_buckets: bucket a date/timestamp field by DAY/WEEK/MONTH/QUARTER/YEAR (e.g. \"revenue by month\").\n- sort: order the result rows by { field, direction } with direction \"asc\" or \"desc\"; rules apply in order (the first is the primary key). Each sorted field must also be listed in fields.\n- fields must list every column the query uses, INCLUDING any field named in aggregations, date_buckets, or sort \u2014 a field you aggregate, bucket, or sort but omit from fields is rejected. Example \u2014 \"revenue by month\": fields [\"ts\", \"revenue\"], aggregations [{field: \"revenue\", function: \"SUM\"}], date_buckets [{field: \"ts\", unit: \"MONTH\"}]. (Filters are the exception: a filter may reference a field that is not in fields.)\n\nChoosing between slices and filters (both are row-level predicates applied to raw values BEFORE any aggregation \u2014 neither can threshold an aggregated total; there is no HAVING):\n- slices (pre-join): narrow a JOINED data mart before it is blended in \u2014 criteria on a joined data mart's own fields only. Slices do NOT apply to the main data mart. More efficient \u2014 they reduce the joined volume before the join. A slice runs on the field's ORIGINAL value, so when get_data_mart_details lists a \"sliceType\" for the field, use operators valid for that pre-join type (not the field's blended-result \"type\").\n- filters (post-join): row-level criteria on the blended result \u2014 use for anything on the MAIN data mart's fields or on a joined field. A filter on a field you also aggregate restricts which raw rows feed the aggregate (e.g. filter revenue > 0 \u2192 SUM over positive rows), NOT the group total.\n- Rule: pre-narrowing a joined data mart's rows \u2192 slices; any other raw-row criterion \u2192 filters.\n- Filtering by an aggregated total (e.g. \"groups whose SUM(revenue) > 100\") is NOT supported \u2014 return all groups with their totals and let the caller compare.\n- Example \u2014 \"orders in the last 3 months\" where orders is a joined data mart: the date range narrows the joined orders before the join \u2192 slices.\n\nUsing the results:\n- Use metrics and totals from the response directly \u2014 never recompute a value already present (totals are computed server-side over all matching rows, so they stay correct even when rows are truncated).\n- The totals block is separate from the rows.\n- When you use aggregations, the rows include an extra \"Row Count\" column \u2014 the number of underlying rows in each group. It is grouping metadata, not one of your requested fields; ignore it unless the user asked how many rows a group contains.\n\nIf truncated is true, not all matching rows were returned: narrow the query (fewer fields, tighter slices/filters) or raise limit (up to 1000).";
+    readonly description = "Query an OWOX data mart and return its data rows in a compact, header-once table, plus server-side totals computed over all matching rows (ignoring the row limit). Each call costs credits.\n\nCall get_data_mart_details_by_id first to get the data mart's exact field names and joinable/blended fields, then copy field names verbatim into fields \u2014 unless you already have that schema in context. Field names must be exact; never guess or invent them.\n\nWhen building the query:\n- Request only the fields relevant to the user's question \u2014 never request all fields.\n- Use limit to control how many rows come back (1\u20131000, default 20). There is no offset/pagination: the tool returns a bounded subset.\n- aggregations: SUM, COUNT, COUNT_DISTINCT, AVG, MIN, MAX, and percentiles P25/P50/P75/P95 \u2014 but each data mart's output controls decide which functions a given field allows, so some may be rejected (pick another, or ask an admin to enable it). Group-by is implied by the non-aggregated fields you select.\n- For \u201Chow many\u201D questions, use COUNT or COUNT_DISTINCT (when the business meaning is unique entities) instead of returning raw rows and counting them yourself. Keep only dimensions the user asked to break the count by.\n- date_buckets: bucket a date/timestamp field by DAY/WEEK/MONTH/QUARTER/YEAR (e.g. \"revenue by month\").\n- sort: order the result rows by { field, direction } with direction \"asc\" or \"desc\"; rules apply in order (the first is the primary key). Each sorted field must also be listed in fields.\n- fields must list every column the query uses, INCLUDING any field named in aggregations, date_buckets, or sort \u2014 a field you aggregate, bucket, or sort but omit from fields is rejected. Example \u2014 \"revenue by month\": fields [\"ts\", \"revenue\"], aggregations [{field: \"revenue\", function: \"SUM\"}], date_buckets [{field: \"ts\", unit: \"MONTH\"}]. (Filters are the exception: a filter may reference a field that is not in fields.)\n\nChoosing between slices and filters (both are row-level predicates applied to raw values BEFORE any aggregation \u2014 neither can threshold an aggregated total; there is no HAVING):\n- slices (pre-join): narrow a JOINED data mart before it is blended in \u2014 criteria on a joined data mart's own fields only. Slices do NOT apply to the main data mart. More efficient \u2014 they reduce the joined volume before the join. A slice runs on the field's ORIGINAL value, so when get_data_mart_details lists a \"sliceType\" for the field, use operators valid for that pre-join type (not the field's blended-result \"type\").\n- filters (post-join): row-level criteria on the blended result \u2014 use for anything on the MAIN data mart's fields or on a joined field. A filter on a field you also aggregate restricts which raw rows feed the aggregate (e.g. filter revenue > 0 \u2192 SUM over positive rows), NOT the group total.\n- Rule: pre-narrowing a joined data mart's rows \u2192 slices; any other raw-row criterion \u2192 filters.\n- Filtering by an aggregated total (e.g. \"groups whose SUM(revenue) > 100\") is NOT supported \u2014 return all groups with their totals and let the caller compare.\n- Example \u2014 \"orders in the last 3 months\" where orders is a joined data mart: the date range narrows the joined orders before the join \u2192 slices.\n\nUsing the results:\n- Use metrics and totals from the response directly \u2014 never recompute a value already present (totals are computed server-side over all matching rows, so they stay correct even when rows are truncated).\n- The totals block is separate from the rows.\n- Totals keys are technical output column names. Match a totals key to column_metadata[].name, not to a business-friendly columns label.\n- When you use aggregations, the rows include an extra \"Row Count\" column \u2014 the number of underlying rows in each group. It is grouping metadata, not one of your requested fields; ignore it unless the user asked how many rows a group contains.\n\nIf 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.";
     readonly zodSchema: {
         data_mart_id: z.ZodString;
         fields: z.ZodArray<z.ZodString, "many">;
@@ -76,10 +78,71 @@ export declare class QueryDataMartTool implements McpToolDefinition<QueryDataMar
     };
     readonly outputSchema: {
         columns: z.ZodArray<z.ZodString, "many">;
+        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">;
         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")[];
+        }>>;
         totals: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        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;
+            };
+        }>;
+        calculation_origin: z.ZodObject<{
+            rows: z.ZodLiteral<"taken_from_owox">;
+            totals: z.ZodEnum<["calculated_by_owox", "not_available"]>;
+        }, "strip", z.ZodTypeAny, {
+            totals: "calculated_by_owox" | "not_available";
+            rows: "taken_from_owox";
+        }, {
+            totals: "calculated_by_owox" | "not_available";
+            rows: "taken_from_owox";
+        }>;
+        _instruction: z.ZodString;
     };
     readonly annotations: {
         title: string;
@@ -89,7 +152,7 @@ export declare class QueryDataMartTool implements McpToolDefinition<QueryDataMar
         openWorldHint: boolean;
     };
     readonly requiredScopes: McpScope[];
-    constructor(dataMarts: McpDataMartsFacade, cls: ClsContextService);
+    constructor(dataMarts: McpDataMartsFacade, cls: ClsContextService, publicOriginService: PublicOriginService);
     private parseInput;
     handler(input: QueryDataMartInput, context: McpAuthContext, signal?: AbortSignal): Promise<McpToolResult>;
     private mapError;

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

@@ -20,14 +20,18 @@ const business_violation_exception_1 = require("../../../common/exceptions/busin
 const project_operation_blocked_exception_1 = require("../../../common/exceptions/project-operation-blocked.exception");
 const project_blocked_reason_enum_1 = require("../../../data-marts/enums/project-blocked-reason.enum");
 const cls_context_service_1 = require("../../../common/logger/cls-context.service");
+const public_origin_service_1 = require("../../../common/config/public-origin.service");
 const mcp_tool_diagnostics_1 = require("../observability/mcp-tool-diagnostics");
 const query_data_mart_input_1 = require("./query-data-mart.input");
 const tabular_serializer_1 = require("./tabular-serializer");
 const output_controls_error_mapper_1 = require("./output-controls-error.mapper");
 const mcp_error_mapper_1 = require("../mappers/mcp-error.mapper");
+const data_mart_ui_path_1 = require("./data-mart-ui-path");
+const mcp_public_url_util_1 = require("./mcp-public-url.util");
 let QueryDataMartTool = class QueryDataMartTool {
     dataMarts;
     cls;
+    publicOriginService;
     name = 'query_data_mart';
     description = `Query an OWOX data mart and return its data rows in a compact, header-once table, plus server-side totals computed over all matching rows (ignoring the row limit). Each call costs credits.
 
@@ -37,6 +41,7 @@ When building the query:
 - Request only the fields relevant to the user's question — never request all fields.
 - Use limit to control how many rows come back (1–1000, default 20). There is no offset/pagination: the tool returns a bounded subset.
 - aggregations: SUM, COUNT, COUNT_DISTINCT, AVG, MIN, MAX, and percentiles P25/P50/P75/P95 — but each data mart's output controls decide which functions a given field allows, so some may be rejected (pick another, or ask an admin to enable it). Group-by is implied by the non-aggregated fields you select.
+- For “how many” questions, use COUNT or COUNT_DISTINCT (when the business meaning is unique entities) instead of returning raw rows and counting them yourself. Keep only dimensions the user asked to break the count by.
 - date_buckets: bucket a date/timestamp field by DAY/WEEK/MONTH/QUARTER/YEAR (e.g. "revenue by month").
 - sort: order the result rows by { field, direction } with direction "asc" or "desc"; rules apply in order (the first is the primary key). Each sorted field must also be listed in fields.
 - fields must list every column the query uses, INCLUDING any field named in aggregations, date_buckets, or sort — a field you aggregate, bucket, or sort but omit from fields is rejected. Example — "revenue by month": fields ["ts", "revenue"], aggregations [{field: "revenue", function: "SUM"}], date_buckets [{field: "ts", unit: "MONTH"}]. (Filters are the exception: a filter may reference a field that is not in fields.)
@@ -51,16 +56,43 @@ Choosing between slices and filters (both are row-level predicates applied to ra
 Using the results:
 - Use metrics and totals from the response directly — never recompute a value already present (totals are computed server-side over all matching rows, so they stay correct even when rows are truncated).
 - The totals block is separate from the rows.
+- Totals keys are technical output column names. Match a totals key to column_metadata[].name, not to a business-friendly columns label.
 - When you use aggregations, the rows include an extra "Row Count" column — the number of underlying rows in each group. It is grouping metadata, not one of your requested fields; ignore it unless the user asked how many rows a group contains.
 
-If truncated is true, not all matching rows were returned: narrow the query (fewer fields, tighter slices/filters) or raise limit (up to 1000).`;
+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()),
+        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(),
+        })),
         rows: zod_1.z.string(),
         returned_rows: zod_1.z.number(),
         truncated: zod_1.z.boolean(),
-        totals: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable(),
+        truncation: zod_1.z
+            .object({
+            reasons: zod_1.z.array(zod_1.z.enum(['row_limit', 'payload_byte_cap'])).min(1),
+        })
+            .optional(),
+        totals: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.unknown())
+            .nullable()
+            .describe('Server-side totals keyed by technical output column name. Match each key to column_metadata[].name.'),
+        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(),
+            }),
+        }),
+        calculation_origin: zod_1.z.object({
+            rows: zod_1.z.literal('taken_from_owox'),
+            totals: zod_1.z.enum(['calculated_by_owox', 'not_available']),
+        }),
+        _instruction: zod_1.z.string(),
     };
     annotations = {
         title: 'Query Data Mart',
@@ -70,9 +102,10 @@ If truncated is true, not all matching rows were returned: narrow the query (few
         openWorldHint: false,
     };
     requiredScopes = ['mcp:read', 'mcp:write'];
-    constructor(dataMarts, cls) {
+    constructor(dataMarts, cls, publicOriginService) {
         this.dataMarts = dataMarts;
         this.cls = cls;
+        this.publicOriginService = publicOriginService;
     }
     parseInput(input) {
         return query_data_mart_input_1.queryDataMartInputSchema.parse(input);
@@ -103,13 +136,43 @@ If truncated is true, not all matching rows were returned: narrow the query (few
                 catch {
                 }
             }
-            const { tsv, rowCount, capped } = (0, tabular_serializer_1.serializeTsvWithByteCap)(res.columns, res.rows, tabular_serializer_1.ROWS_PAYLOAD_BYTE_CAP);
+            const displayColumns = (0, tabular_serializer_1.formatTsvColumnLabels)(res.columnMetadata);
+            const { tsv, headerColumns, rowCount, capped } = (0, tabular_serializer_1.serializeTsvWithByteCap)(displayColumns, res.rows, tabular_serializer_1.ROWS_PAYLOAD_BYTE_CAP);
+            const truncationReasons = [
+                ...(res.truncated ? ['row_limit'] : []),
+                ...(capped ? ['payload_byte_cap'] : []),
+            ];
+            const isTruncated = truncationReasons.length > 0;
+            const totalsKeyInstruction = res.totals
+                ? ' Totals keys are technical output names; match them to column_metadata[].name, not to display labels.'
+                : '';
             const structuredContent = {
-                columns: res.columns,
+                columns: headerColumns,
+                column_metadata: res.columnMetadata.map((column, index) => ({
+                    name: column.name,
+                    display_name: headerColumns[index],
+                    ...(column.description ? { description: column.description } : {}),
+                    ...(column.type ? { type: column.type } : {}),
+                })),
                 rows: tsv,
                 returned_rows: rowCount,
-                truncated: res.truncated || capped,
+                truncated: isTruncated,
+                ...(isTruncated ? { truncation: { reasons: truncationReasons } } : {}),
                 totals: res.totals,
+                source: {
+                    data_mart: {
+                        id: res.dataMart.id,
+                        title: res.dataMart.title,
+                        url: (0, mcp_public_url_util_1.joinPublicOrigin)(this.publicOriginService.getPublicOrigin(), (0, data_mart_ui_path_1.buildDataMartUiPath)(context.projectId, res.dataMart.id)),
+                    },
+                },
+                calculation_origin: {
+                    rows: 'taken_from_owox',
+                    totals: res.totals ? 'calculated_by_owox' : 'not_available',
+                },
+                _instruction: isTruncated
+                    ? `IMPORTANT: Rows are incomplete. Tell the user explicitly that the result was truncated and that any conclusion based on rows may be incomplete. State the Data Mart source. Server-provided totals still cover all matching rows; do not describe a value you calculate from returned rows as an OWOX-calculated total.${totalsKeyInstruction}`
+                    : `State which Data Mart supplied the data. Identify server-provided rows and totals as taken from or calculated by OWOX. If you perform arithmetic from those values yourself, label it as an AI-side calculation.${totalsKeyInstruction}`,
             };
             return {
                 structuredContent,
@@ -179,6 +242,7 @@ exports.QueryDataMartTool = QueryDataMartTool;
 exports.QueryDataMartTool = QueryDataMartTool = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(mcp_data_marts_facade_1.MCP_DATA_MARTS_FACADE)),
-    __metadata("design:paramtypes", [Object, cls_context_service_1.ClsContextService])
+    __metadata("design:paramtypes", [Object, cls_context_service_1.ClsContextService,
+        public_origin_service_1.PublicOriginService])
 ], QueryDataMartTool);
 //# sourceMappingURL=query-data-mart.tool.js.map

package/dist/src/ee/mcp/tools/search-data-marts.tool.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { McpScope } from '@owox/idp-protocol';
 import { type SearchFacade } from '../../../common/search/search.facade';
 import { PublicOriginService } from '../../../common/config/public-origin.service';
+import { type McpProjectContextFacade } from '../../../idp/facades/mcp-project-context.facade';
 import type { McpAuthContext } from '../auth/mcp-auth-context';
 import { type McpToolDefinition, type McpToolResult } from './mcp-tool.definition';
 declare const inputSchema: z.ZodObject<{
@@ -18,6 +19,7 @@ type SearchDataMartsInput = z.infer<typeof inputSchema>;
 export declare class SearchDataMartsTool implements McpToolDefinition<SearchDataMartsInput> {
     private readonly searchFacade;
     private readonly publicOriginService;
+    private readonly projectContext;
     readonly name = "get_relevant_data_marts_by_prompt";
     readonly description = "Find relevant non-draft data marts in the current OWOX project from a natural-language prompt, limited to data marts visible to the current MCP user. This is the default discovery step for a concrete analytical question when the data mart has not already been confirmed. Use it when the user asks to find, discover, or search published data marts by title, description, business meaning, schema fields, or metrics. This tool returns only data marts, not data storages or destinations, and it intentionally excludes draft data marts.";
     readonly zodSchema: {
@@ -25,6 +27,16 @@ export declare class SearchDataMartsTool implements McpToolDefinition<SearchData
         limit: z.ZodOptional<z.ZodNumber>;
     };
     readonly outputSchema: {
+        project: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            title: string;
+        }, {
+            id: string;
+            title: string;
+        }>>;
         data_marts: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             title: z.ZodString;
@@ -52,7 +64,7 @@ export declare class SearchDataMartsTool implements McpToolDefinition<SearchData
         openWorldHint: boolean;
     };
     readonly requiredScopes: McpScope[];
-    constructor(searchFacade: SearchFacade, publicOriginService: PublicOriginService);
+    constructor(searchFacade: SearchFacade, publicOriginService: PublicOriginService, projectContext: McpProjectContextFacade);
     parseInput(input: unknown): SearchDataMartsInput;
     handler(input: SearchDataMartsInput, context: McpAuthContext): Promise<McpToolResult>;
 }

package/dist/src/ee/mcp/tools/search-data-marts.tool.js

@@ -17,8 +17,10 @@ const common_1 = require("@nestjs/common");
 const zod_1 = require("zod");
 const search_facade_1 = require("../../../common/search/search.facade");
 const public_origin_service_1 = require("../../../common/config/public-origin.service");
+const mcp_project_context_facade_1 = require("../../../idp/facades/mcp-project-context.facade");
 const mcp_tool_definition_1 = require("./mcp-tool.definition");
 const data_mart_ui_path_1 = require("./data-mart-ui-path");
+const mcp_project_summary_util_1 = require("./mcp-project-summary.util");
 const mcp_public_url_util_1 = require("./mcp-public-url.util");
 const DEFAULT_LIMIT = 10;
 const MAX_LIMIT = 25;
@@ -31,10 +33,12 @@ const inputSchema = zod_1.z
 let SearchDataMartsTool = class SearchDataMartsTool {
     searchFacade;
     publicOriginService;
+    projectContext;
     name = 'get_relevant_data_marts_by_prompt';
     description = 'Find relevant non-draft data marts in the current OWOX project from a natural-language prompt, limited to data marts visible to the current MCP user. This is the default discovery step for a concrete analytical question when the data mart has not already been confirmed. Use it when the user asks to find, discover, or search published data marts by title, description, business meaning, schema fields, or metrics. This tool returns only data marts, not data storages or destinations, and it intentionally excludes draft data marts.';
     zodSchema = inputSchema.shape;
     outputSchema = {
+        project: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string() }).optional(),
         data_marts: zod_1.z.array(zod_1.z.object({
             id: zod_1.z.string(),
             title: zod_1.z.string(),
@@ -50,26 +54,31 @@ let SearchDataMartsTool = class SearchDataMartsTool {
         openWorldHint: false,
     };
     requiredScopes = ['mcp:read'];
-    constructor(searchFacade, publicOriginService) {
+    constructor(searchFacade, publicOriginService, projectContext) {
         this.searchFacade = searchFacade;
         this.publicOriginService = publicOriginService;
+        this.projectContext = projectContext;
     }
     parseInput(input) {
         return inputSchema.parse(input);
     }
     async handler(input, context) {
         const parsed = this.parseInput(input);
-        const results = await this.searchFacade.search(context.projectId, parsed.prompt, {
-            topK: parsed.limit ?? DEFAULT_LIMIT,
-            entityTypes: [search_facade_1.SearchableEntityType.DATA_MART],
-            excludeDrafts: true,
-            accessScope: {
-                userId: context.userId,
-                roles: context.roles,
-            },
-        });
+        const [results, projectContext] = await Promise.all([
+            this.searchFacade.search(context.projectId, parsed.prompt, {
+                topK: parsed.limit ?? DEFAULT_LIMIT,
+                entityTypes: [search_facade_1.SearchableEntityType.DATA_MART],
+                excludeDrafts: true,
+                accessScope: {
+                    userId: context.userId,
+                    roles: context.roles,
+                },
+            }),
+            (0, mcp_project_summary_util_1.tryGetMcpProjectSummary)(this.projectContext, context),
+        ]);
         const publicOrigin = this.publicOriginService.getPublicOrigin();
         const structuredContent = {
+            ...(projectContext ? { project: projectContext } : {}),
             data_marts: results
                 .filter(result => result.entityType === search_facade_1.SearchableEntityType.DATA_MART)
                 .map(result => ({
@@ -87,6 +96,7 @@ exports.SearchDataMartsTool = SearchDataMartsTool;
 exports.SearchDataMartsTool = SearchDataMartsTool = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(search_facade_1.SEARCH_FACADE)),
-    __metadata("design:paramtypes", [Object, public_origin_service_1.PublicOriginService])
+    __param(2, (0, common_1.Inject)(mcp_project_context_facade_1.MCP_PROJECT_CONTEXT_FACADE)),
+    __metadata("design:paramtypes", [Object, public_origin_service_1.PublicOriginService, Object])
 ], SearchDataMartsTool);
 //# sourceMappingURL=search-data-marts.tool.js.map

package/dist/src/ee/mcp/tools/summarize-data-catalog.tool.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import type { McpScope } from '@owox/idp-protocol';
 import { PublicOriginService } from '../../../common/config/public-origin.service';
+import { type McpProjectContextFacade } from '../../../idp/facades/mcp-project-context.facade';
 import { type McpDataMartsFacade } from '../../../data-marts/facades/mcp-data-marts.facade';
 import type { McpAuthContext } from '../auth/mcp-auth-context';
 import type { McpToolDefinition, McpToolResult } from './mcp-tool.definition';
@@ -9,10 +10,21 @@ type SummarizeDataCatalogInput = z.infer<typeof inputSchema>;
 export declare class SummarizeDataCatalogTool implements McpToolDefinition<SummarizeDataCatalogInput> {
     private readonly dataMarts;
     private readonly publicOriginService;
+    private readonly projectContext;
     readonly name = "summarize_data_catalog";
     readonly description = "Returns a high-level summary input for the current OWOX project published Data Mart catalog so the LLM can orient the user. Use when the user asks open-ended questions like \"what data is available here?\", \"what can I analyze?\", or \"where should I start?\". The tool returns counts and top published Data Marts ranked by configured relationship connectivity, with shortened descriptions and basic usage metadata. It does not query actual data rows, compute data freshness, or generate a natural-language summary.";
     readonly zodSchema: {};
     readonly outputSchema: {
+        project: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            title: string;
+        }, {
+            id: string;
+            title: string;
+        }>>;
         project_id: z.ZodString;
         data_mart_count: z.ZodNumber;
         top_data_marts_by_connectivity: z.ZodArray<z.ZodObject<{
@@ -52,7 +64,7 @@ export declare class SummarizeDataCatalogTool implements McpToolDefinition<Summa
         openWorldHint: boolean;
     };
     readonly requiredScopes: McpScope[];
-    constructor(dataMarts: McpDataMartsFacade, publicOriginService: PublicOriginService);
+    constructor(dataMarts: McpDataMartsFacade, publicOriginService: PublicOriginService, projectContext: McpProjectContextFacade);
     parseInput(input: unknown): SummarizeDataCatalogInput;
     handler(input: SummarizeDataCatalogInput, context: McpAuthContext): Promise<McpToolResult>;
 }

package/dist/src/ee/mcp/tools/summarize-data-catalog.tool.js

@@ -16,18 +16,22 @@ exports.SummarizeDataCatalogTool = void 0;
 const common_1 = require("@nestjs/common");
 const zod_1 = require("zod");
 const public_origin_service_1 = require("../../../common/config/public-origin.service");
+const mcp_project_context_facade_1 = require("../../../idp/facades/mcp-project-context.facade");
 const mcp_data_marts_facade_1 = require("../../../data-marts/facades/mcp-data-marts.facade");
 const data_mart_ui_path_1 = require("./data-mart-ui-path");
+const mcp_project_summary_util_1 = require("./mcp-project-summary.util");
 const mcp_public_url_util_1 = require("./mcp-public-url.util");
 const inputSchema = zod_1.z.object({}).strict();
 const INSTRUCTION = 'You have received a high-level summary of the published Data Mart catalog available to this MCP connection. Summarize the business areas covered by the listed Data Marts and suggest 4-6 concrete example prompts the user could ask. Do not claim access to data rows, sample values, row counts, or freshness details.';
 let SummarizeDataCatalogTool = class SummarizeDataCatalogTool {
     dataMarts;
     publicOriginService;
+    projectContext;
     name = 'summarize_data_catalog';
     description = 'Returns a high-level summary input for the current OWOX project published Data Mart catalog so the LLM can orient the user. Use when the user asks open-ended questions like "what data is available here?", "what can I analyze?", or "where should I start?". The tool returns counts and top published Data Marts ranked by configured relationship connectivity, with shortened descriptions and basic usage metadata. It does not query actual data rows, compute data freshness, or generate a natural-language summary.';
     zodSchema = inputSchema.shape;
     outputSchema = {
+        project: zod_1.z.object({ id: zod_1.z.string(), title: zod_1.z.string() }).optional(),
         project_id: zod_1.z.string(),
         data_mart_count: zod_1.z.number(),
         top_data_marts_by_connectivity: zod_1.z.array(zod_1.z.object({
@@ -49,22 +53,27 @@ let SummarizeDataCatalogTool = class SummarizeDataCatalogTool {
         openWorldHint: false,
     };
     requiredScopes = ['mcp:read'];
-    constructor(dataMarts, publicOriginService) {
+    constructor(dataMarts, publicOriginService, projectContext) {
         this.dataMarts = dataMarts;
         this.publicOriginService = publicOriginService;
+        this.projectContext = projectContext;
     }
     parseInput(input) {
         return inputSchema.parse(input);
     }
     async handler(input, context) {
         this.parseInput(input);
-        const result = await this.dataMarts.summarizeDataCatalog({
-            projectId: context.projectId,
-            userId: context.userId,
-            roles: context.roles,
-        });
+        const [result, projectContext] = await Promise.all([
+            this.dataMarts.summarizeDataCatalog({
+                projectId: context.projectId,
+                userId: context.userId,
+                roles: context.roles,
+            }),
+            (0, mcp_project_summary_util_1.tryGetMcpProjectSummary)(this.projectContext, context),
+        ]);
         const publicOrigin = this.publicOriginService.getPublicOrigin();
         const structuredContent = {
+            ...(projectContext ? { project: projectContext } : {}),
             project_id: result.projectId,
             data_mart_count: result.dataMartCount,
             top_data_marts_by_connectivity: result.topDataMartsByConnectivity.map(dataMart => ({
@@ -94,6 +103,7 @@ exports.SummarizeDataCatalogTool = SummarizeDataCatalogTool;
 exports.SummarizeDataCatalogTool = SummarizeDataCatalogTool = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(mcp_data_marts_facade_1.MCP_DATA_MARTS_FACADE)),
-    __metadata("design:paramtypes", [Object, public_origin_service_1.PublicOriginService])
+    __param(2, (0, common_1.Inject)(mcp_project_context_facade_1.MCP_PROJECT_CONTEXT_FACADE)),
+    __metadata("design:paramtypes", [Object, public_origin_service_1.PublicOriginService, Object])
 ], SummarizeDataCatalogTool);
 //# sourceMappingURL=summarize-data-catalog.tool.js.map

package/dist/src/ee/mcp/tools/tabular-serializer.d.ts

@@ -1,6 +1,12 @@
 export declare const ROWS_PAYLOAD_BYTE_CAP = 131072;
+export interface TsvColumnLabel {
+    name: string;
+    displayName: string;
+}
+export declare function formatTsvColumnLabels(columns: readonly TsvColumnLabel[]): string[];
 export declare function serializeTsvWithByteCap(columns: string[], rows: unknown[][], maxBytes: number): {
     tsv: string;
+    headerColumns: string[];
     rowCount: number;
     capped: boolean;
 };