@uipath/apollo-vertex 0.0.0-stage → 0.1.0

package/dist/registry/ai-chat/tools/data-fabric-multi-line/data-fabric-multi-line-tool.js

@@ -0,0 +1,166 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { toolDefinition } from "@tanstack/ai";
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { dataFabricAdapter } from "../../../data-fabric-adapter/data-fabric-adapter.js";
+import { MultiLineChartCard } from "../../charts/multi-line-chart-card.js";
+import { ToolResolutionError } from "../../charts/tool-resolution-error.js";
+import { buildMultiMetricDataModel, dedupeMetrics, metricSchema, resolveMultiDimension, resolveMultiMetric, resolveSingleDimension, resolveSingleMetric } from "../data-fabric/util/chart-helpers.js";
+import { collectQualifiedFields, generateEntityFieldsDocs } from "../data-fabric/util/entities.js";
+import { filterSchema, resolveFilters } from "../data-fabric/util/filters.js";
+import { joinSchema } from "../data-fabric/util/joins.js";
+const MULTI_LINE_DIMENSION_TYPES = [
+    "datetime"
+];
+const dataFabricMultiLineInput = z.object({
+    entityName: z.string().describe("Data Fabric entity name to query"),
+    dimension: z.string().describe("Datetime field name to bin the time axis by. When joining, use EntityName.Field format."),
+    metrics: z.array(metricSchema).min(2).max(2).refine((metrics)=>{
+        const keys = new Set(metrics.map((m)=>`${m.aggregation}|${m.field ?? ""}`));
+        return keys.size === metrics.length;
+    }, {
+        message: "Metrics must have distinct (aggregation, field) pairs — pick two different metrics to compare."
+    }).describe("Exactly two metrics with distinct (aggregation, field) pairs, plotted as separate lines on a shared time axis. The first metric uses the left Y axis; the second uses the right."),
+    filters: z.array(filterSchema).optional().describe("Optional filters to narrow down results."),
+    joins: z.array(joinSchema).optional().describe("Join other entities. Use EntityName.Field format for the dimension and metric fields when joining.")
+});
+const dataFabricMultiLineDef = toolDefinition({
+    name: "data_fabric_multi_line",
+    description: "Render a multi-line chart from a Data Fabric entity, plotting exactly two metrics over a datetime dimension on a shared X axis (one per Y axis: left and right). Use when the user wants to compare two metrics over time.",
+    inputSchema: dataFabricMultiLineInput,
+    outputSchema: dataFabricMultiLineInput,
+    metadata: {
+        skipFollowUp: true
+    }
+});
+const dataFabricMultiLineClient = dataFabricMultiLineDef.client((input)=>input);
+function createDataFabricMultiLineTool(context) {
+    const today = DateTime.now().toISODate();
+    const toolPrompt = `You have a "data_fabric_multi_line" tool.
+Use it to render a multi-line chart that plots EXACTLY TWO metrics over time on a shared datetime X axis.
+
+## When to use multi-line vs line
+- Use "data_fabric_multi_line" when the user asks to compare two metrics on the same time axis (e.g. "orders count and revenue over time", "min vs max price by month", "sum of A and sum of B per quarter").
+- Use "data_fabric_line" when there is only ONE metric to plot. Do NOT call multi-line with a single metric.
+- The chart only supports 2 metrics: the FIRST metric uses the LEFT Y axis (and its color/totals label), the SECOND uses the RIGHT. If the user asks to compare 3+ metrics, ask them to pick the two most important and offer to render the others in follow-up charts — do NOT pass more than 2.
+
+## Dimension
+- Pass exactly one "dimension" — a datetime field name on the chosen entity (see Entity Reference). The field MUST be a datetime field; do NOT use this tool with a numeric or string dimension.
+- When the user explicitly names a field (e.g. "<metric_a> and <metric_b> over EntityName.Field"), use EXACTLY that field as the dimension.
+- If the user-named field is not a datetime field, do NOT call this tool. Reply explaining that line charts require a datetime field, and list the candidate datetime fields on that entity.
+
+## Metrics
+- Pass an array of EXACTLY TWO metrics with distinct (aggregation, field) pairs. Each entry follows the same shape as the line tool:
+  - For COUNT, pass { aggregation: "COUNT" } — "field" is optional and defaults to the entity primary key.
+  - For SUM/AVG/MIN/MAX, pass { aggregation, field } where "field" is a numeric field on the chosen entity.
+- Pick only metrics the user asked to compare. Do not invent extra metrics.
+- Two metrics with the same (aggregation, field) pair are duplicates and the tool call will be REJECTED at validation. Make sure the two metrics differ in either aggregation, field, or both.
+- Order matters: put the metric you want emphasized (or with the larger scale) first, since it gets the left axis and the primary color.
+
+## Filters
+You can optionally pass filters to narrow results. Available filter types:
+- **list**: match specific values. Use valueType matching the field type (string/number/boolean). Set invert=true to exclude.
+- **search**: text pattern matching on string fields. searchFilterType: "default" (contains), "startsWith", "endsWith".
+- **range** (numeric): use valueType="number" with min/max numbers.
+- **range** (datetime): use valueType="datetime" with min/max as ISO 8601 strings (e.g. "2026-01-01" or "2026-01-01T00:00:00Z"). Today is ${today} — use it to resolve relative phrases like "last 30 days" or "this year" into absolute ISO dates before passing them.
+Only add filters when the user asks to filter, search, or narrow results.
+
+## Multi-Entity Joins
+To bin a datetime field that lives on a joined entity, or to aggregate a numeric field from a joined entity, add "joins" to link related entities. The entityName field is the primary entity.
+When using joins, use qualified field names everywhere: "EntityName.FieldName" (using the EXACT entity names from the Entity Reference, never abbreviations or aliases).
+Only use joins when the user explicitly asks to combine data from multiple entities.
+
+## Entity Reference
+${generateEntityFieldsDocs(context.entities)}`;
+    function renderMultiLine(output, id) {
+        const { entityName, dimension, metrics, filters, joins } = output;
+        const isMultiEntity = null != joins && joins.length > 0;
+        const entity = context.entities[entityName];
+        if (!entity) return /*#__PURE__*/ jsx(ToolResolutionError, {
+            failure: {
+                reason: "unknown_entity",
+                entity: entityName
+            }
+        });
+        const qualifiedFields = isMultiEntity ? collectQualifiedFields([
+            entityName,
+            ...joins.map((j)=>j.entity)
+        ], context.entities) : null;
+        const resolvedDimension = qualifiedFields ? resolveMultiDimension(entityName, dimension, qualifiedFields, MULTI_LINE_DIMENSION_TYPES) : resolveSingleDimension(entity, dimension, MULTI_LINE_DIMENSION_TYPES);
+        if (!resolvedDimension.ok) return /*#__PURE__*/ jsx(ToolResolutionError, {
+            failure: resolvedDimension
+        });
+        const resolvedMetrics = [];
+        const metricFailures = [];
+        for (const metric of metrics){
+            const result = qualifiedFields ? resolveMultiMetric(entityName, metric, qualifiedFields) : resolveSingleMetric(entity, metric);
+            if (result.ok) resolvedMetrics.push(result.value);
+            else {
+                const { ok: _ok, ...failure } = result;
+                metricFailures.push(failure);
+            }
+        }
+        const uniqueMetrics = dedupeMetrics(resolvedMetrics);
+        if (uniqueMetrics.length < 2) {
+            const firstFailure = metricFailures[0];
+            if (firstFailure) return /*#__PURE__*/ jsx(ToolResolutionError, {
+                failure: firstFailure
+            });
+            return /*#__PURE__*/ jsx(ToolResolutionError, {
+                failure: {
+                    reason: "multi_line_too_few_metrics"
+                }
+            });
+        }
+        const dataModel = buildMultiMetricDataModel({
+            id: entityName,
+            dimension: resolvedDimension.value.id,
+            dimensionType: resolvedDimension.value.type,
+            metrics: uniqueMetrics
+        });
+        const normalizedFilters = qualifiedFields ? resolveFilters(filters, {
+            mode: "multi",
+            primaryEntity: entityName,
+            qualifiedFields
+        }) : resolveFilters(filters, {
+            mode: "single",
+            validFields: entity.fields.map((f)=>f.name)
+        });
+        const configuration = {
+            id,
+            name: entityName,
+            type: "multi_line",
+            dimensions: [
+                resolvedDimension.value.id
+            ],
+            metrics: dataModel.metrics.map((m)=>m.id),
+            filters: normalizedFilters,
+            ...qualifiedFields && joins && {
+                from: {
+                    entity: entityName,
+                    alias: entityName
+                },
+                joins: joins.map((j)=>({
+                        ...j,
+                        alias: j.entity
+                    }))
+            }
+        };
+        const adapter = dataFabricAdapter({
+            baseUrl: context.dataFabricBaseUrl,
+            accessToken: context.accessToken,
+            entityName
+        });
+        return /*#__PURE__*/ jsx(MultiLineChartCard, {
+            configuration: configuration,
+            dataModel: dataModel,
+            dataAdapter: adapter
+        });
+    }
+    return {
+        toolPrompt,
+        renderMultiLine
+    };
+}
+export { createDataFabricMultiLineTool, dataFabricMultiLineClient };

package/dist/registry/ai-chat/tools/data-fabric-multi-line/index.d.ts

@@ -0,0 +1 @@
+export { createDataFabricMultiLineTool, dataFabricMultiLineClient, } from "./data-fabric-multi-line-tool";

package/dist/registry/ai-chat/tools/data-fabric-multi-line/index.js

@@ -0,0 +1,2 @@
+import { createDataFabricMultiLineTool, dataFabricMultiLineClient } from "./data-fabric-multi-line-tool.js";
+export { createDataFabricMultiLineTool, dataFabricMultiLineClient };

package/dist/registry/ai-chat/tools/data-fabric-table/data-fabric-table-tool.d.ts

@@ -0,0 +1,204 @@
+import { z } from "zod";
+import { type DataFabricToolContext } from "../data-fabric/util/entities";
+declare const dataFabricTableInput: z.ZodObject<{
+    entityName: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"boolean">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"search">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        pattern: z.ZodString;
+        searchFilterType: z.ZodEnum<{
+            endsWith: "endsWith";
+            startsWith: "startsWith";
+            default: "default";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        range: z.ZodUnion<readonly [z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"datetime">;
+        range: z.ZodObject<{
+            min: z.ZodString;
+            max: z.ZodString;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const dataFabricTableClient: import("@tanstack/ai").ClientTool<z.ZodObject<{
+    entityName: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"boolean">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"search">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        pattern: z.ZodString;
+        searchFilterType: z.ZodEnum<{
+            endsWith: "endsWith";
+            startsWith: "startsWith";
+            default: "default";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        range: z.ZodUnion<readonly [z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"datetime">;
+        range: z.ZodObject<{
+            min: z.ZodString;
+            max: z.ZodString;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    entityName: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"boolean">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNull]>>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"search">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"string">;
+        pattern: z.ZodString;
+        searchFilterType: z.ZodEnum<{
+            endsWith: "endsWith";
+            startsWith: "startsWith";
+            default: "default";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"number">;
+        range: z.ZodUnion<readonly [z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        valueType: z.ZodLiteral<"datetime">;
+        range: z.ZodObject<{
+            min: z.ZodString;
+            max: z.ZodString;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, "data_fabric_table">;
+export declare function createDataFabricTableTool(context: DataFabricToolContext): {
+    toolPrompt: string;
+    renderTable: (output: z.infer<typeof dataFabricTableInput>, id: string) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/registry/ai-chat/tools/data-fabric-table/data-fabric-table-tool.js

@@ -0,0 +1,137 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { toolDefinition } from "@tanstack/ai";
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { dataFabricAdapter } from "../../../data-fabric-adapter/data-fabric-adapter.js";
+import { TableChartCard } from "../../charts/table-chart-card.js";
+import { ToolResolutionError } from "../../charts/tool-resolution-error.js";
+import { collectQualifiedFields, generateEntityFieldsDocs } from "../data-fabric/util/entities.js";
+import { filterSchema, resolveFilters } from "../data-fabric/util/filters.js";
+import { joinSchema } from "../data-fabric/util/joins.js";
+import { buildMultiEntityDataModel, buildTableDataModel, validateDimensions } from "./table-data-model.js";
+const dataFabricTableInput = z.object({
+    entityName: z.string().describe("Data Fabric entity name to query"),
+    dimensions: z.array(z.string()).min(1).describe("Field names to display as table columns."),
+    filters: z.array(filterSchema).optional().describe("Optional filters to narrow down results."),
+    joins: z.array(joinSchema).optional().describe("Join other entities. Use EntityName.Field format for dimensions and join conditions when joining.")
+});
+const dataFabricTableDef = toolDefinition({
+    name: "data_fabric_table",
+    description: "Display data from a Data Fabric entity as a table. Call this when the user wants to see data, view records, or display information about entities. Supports optional filters (list, search, range — including datetime ranges) to narrow results. Only use fields that exist for the chosen entity.",
+    inputSchema: dataFabricTableInput,
+    outputSchema: dataFabricTableInput,
+    metadata: {
+        skipFollowUp: true
+    }
+});
+const dataFabricTableClient = dataFabricTableDef.client((input)=>input);
+function buildSingleEntityResult(entity, dimensions) {
+    const fieldNames = entity.fields.map((f)=>f.name);
+    return {
+        mode: "single",
+        validDimensions: validateDimensions(dimensions, fieldNames),
+        dataModel: buildTableDataModel(entity),
+        fieldNames
+    };
+}
+function buildMultiEntityResult(primaryEntity, dimensions, joins, entities) {
+    const allEntityNames = [
+        primaryEntity,
+        ...joins.map((j)=>j.entity)
+    ];
+    const qualifiedFields = collectQualifiedFields(allEntityNames, entities);
+    const normalizedDimensions = dimensions.map((d)=>d.includes(".") ? d : `${primaryEntity}.${d}`);
+    const validDimensions = validateDimensions(normalizedDimensions, qualifiedFields.keys());
+    return {
+        mode: "multi",
+        validDimensions,
+        dataModel: buildMultiEntityDataModel(primaryEntity, validDimensions, qualifiedFields),
+        qualifiedFields
+    };
+}
+function createDataFabricTableTool(context) {
+    const today = DateTime.now().toISODate();
+    const toolPrompt = `You have a "data_fabric_table" tool.
+When the user wants to see data as a table, call it with the entity name and field names as dimensions.
+If the user asks for specific fields, use exactly those fields.
+If the user does not specify fields, pick a reasonable default set (3-8 fields).
+Only use fields that exist for the chosen entity (see Entity Reference).
+
+## Filters
+You can optionally pass filters to narrow results. Available filter types:
+- **list**: match specific values. Use valueType matching the field type (string/number/boolean). Set invert=true to exclude.
+- **search**: text pattern matching on string fields. searchFilterType: "default" (contains), "startsWith", "endsWith".
+- **range** (numeric): use valueType="number" with min/max numbers.
+- **range** (datetime): use valueType="datetime" with min/max as ISO 8601 strings (e.g. "2026-01-01" or "2026-01-01T00:00:00Z"). Today is ${today} — use it to resolve relative phrases like "last 30 days" or "this year" into absolute ISO dates before passing them.
+Only add filters when the user asks to filter, search, or narrow results.
+
+## Multi-Entity Joins
+To query across multiple entities, add "joins" to link related entities. The entityName field is the primary entity.
+When using joins, use qualified field names everywhere: "EntityName.FieldName" (using the EXACT entity names from the Entity Reference, never abbreviations or aliases).
+When joining, always include relevant fields from BOTH the primary entity and the joined entity in dimensions — not just the joined entity's fields.
+The join condition is specified in "joins[].on" — do NOT also add a filter for the join condition.
+Only use joins when the user explicitly asks to combine data from multiple entities.
+
+## Entity Reference
+${generateEntityFieldsDocs(context.entities)}`;
+    function renderTable(output, id) {
+        const { entityName, dimensions, filters, joins } = output;
+        const isMultiEntity = null != joins && joins.length > 0;
+        const entity = context.entities[entityName];
+        if (!entity) return /*#__PURE__*/ jsx(ToolResolutionError, {
+            failure: {
+                reason: "unknown_entity",
+                entity: entityName
+            }
+        });
+        const result = isMultiEntity ? buildMultiEntityResult(entityName, dimensions, joins, context.entities) : buildSingleEntityResult(entity, dimensions);
+        if (0 === result.validDimensions.length) return /*#__PURE__*/ jsx(ToolResolutionError, {
+            failure: {
+                reason: "table_no_valid_fields",
+                entity: entityName,
+                fields: dimensions.join(", ")
+            }
+        });
+        const normalizedFilters = "multi" === result.mode ? resolveFilters(filters, {
+            mode: "multi",
+            primaryEntity: entityName,
+            qualifiedFields: result.qualifiedFields
+        }) : resolveFilters(filters, {
+            mode: "single",
+            validFields: result.fieldNames
+        });
+        const configuration = {
+            id,
+            name: entityName,
+            type: "table",
+            dimensions: result.validDimensions,
+            filters: normalizedFilters,
+            ..."multi" === result.mode && joins && {
+                from: {
+                    entity: entityName,
+                    alias: entityName
+                },
+                joins: joins.map((j)=>({
+                        ...j,
+                        alias: j.entity
+                    }))
+            }
+        };
+        const adapter = dataFabricAdapter({
+            baseUrl: context.dataFabricBaseUrl,
+            accessToken: context.accessToken,
+            entityName
+        });
+        return /*#__PURE__*/ jsx(TableChartCard, {
+            configuration: configuration,
+            dataModel: result.dataModel,
+            dataAdapter: adapter
+        });
+    }
+    return {
+        toolPrompt,
+        renderTable
+    };
+}
+export { createDataFabricTableTool, dataFabricTableClient };

package/dist/registry/ai-chat/tools/data-fabric-table/index.d.ts

@@ -0,0 +1 @@
+export { createDataFabricTableTool, dataFabricTableClient, } from "./data-fabric-table-tool";

package/dist/registry/ai-chat/tools/data-fabric-table/index.js

@@ -0,0 +1,2 @@
+import { createDataFabricTableTool, dataFabricTableClient } from "./data-fabric-table-tool.js";
+export { createDataFabricTableTool, dataFabricTableClient };

package/dist/registry/ai-chat/tools/data-fabric-table/table-data-model.d.ts

@@ -0,0 +1,5 @@
+import { type TableDataModel } from "../../../charts-core/charts-core";
+import { type Entity, type EntityField } from "../data-fabric/util/entities";
+export declare function buildTableDataModel(entity: Entity): TableDataModel;
+export declare function buildMultiEntityDataModel(id: string, dimensions: string[], fields: Map<string, EntityField>): TableDataModel;
+export declare function validateDimensions(dimensions: string[], validNames: Iterable<string>): string[];

package/dist/registry/ai-chat/tools/data-fabric-table/table-data-model.js

@@ -0,0 +1,24 @@
+import { assert } from "../../../../lib/asserts/assert.js";
+import { buildField } from "../../../charts-core/charts-core.js";
+import { mapFieldType } from "../data-fabric/util/entities.js";
+function buildTableDataModel(entity) {
+    return {
+        id: entity.id,
+        fields: entity.fields.map((field)=>buildField(field.name, mapFieldType(field.dataType)))
+    };
+}
+function buildMultiEntityDataModel(id, dimensions, fields) {
+    return {
+        id,
+        fields: dimensions.map((d)=>{
+            const field = fields.get(d);
+            assert(null != field, `buildMultiEntityDataModel: dimension "${d}" is not present in qualified fields. Caller must validate dimensions first.`);
+            return buildField(d, mapFieldType(field.dataType));
+        })
+    };
+}
+function validateDimensions(dimensions, validNames) {
+    const valid = new Set(validNames);
+    return dimensions.filter((d)=>valid.has(d));
+}
+export { buildMultiEntityDataModel, buildTableDataModel, validateDimensions };

package/dist/registry/ai-chat/types.d.ts

@@ -0,0 +1 @@
+export type MessageFeedbackType = "positive" | "negative";

package/dist/registry/ai-glow/ai-glow.d.ts

@@ -0,0 +1,24 @@
+import { type VariantProps } from "class-variance-authority";
+declare const aiGlowVariants: (props?: ({
+    variant?: "group" | "card" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface AiGlowProps extends React.ComponentProps<"div">, VariantProps<typeof aiGlowVariants> {
+}
+/**
+ * A decorative AI glow that sits behind a card or a group of cards. Render it as
+ * the first child of a `relative` parent, with the content layered above it in a
+ * `relative` wrapper:
+ *
+ * ```tsx
+ * <div className="relative">
+ *   <AiGlow />
+ *   <div className="relative">{card}</div>
+ * </div>
+ * ```
+ *
+ * The `card` variant is a blurred gradient blob; the `group` variant is a wider,
+ * organic SVG wash. The element is `aria-hidden` and ignores pointer events.
+ */
+declare function AiGlow({ variant, className, style, ...props }: AiGlowProps): import("react/jsx-runtime").JSX.Element;
+export { AiGlow, aiGlowVariants };
+export type { AiGlowProps };