@uipath/apollo-vertex 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,8 @@
+import { createDataFabricBarTool } from "../data-fabric-bar/index.js";
+import { createDataFabricDistributionTool } from "../data-fabric-distribution/index.js";
+import { createDataFabricKpiTool } from "../data-fabric-kpi/index.js";
+import { createDataFabricLineTool } from "../data-fabric-line/index.js";
+import { createDataFabricMultiLineTool } from "../data-fabric-multi-line/index.js";
+import { createDataFabricTableTool } from "../data-fabric-table/index.js";
+import { generateEntityFieldsDocs } from "./util/entities.js";
+export { createDataFabricBarTool, createDataFabricDistributionTool, createDataFabricKpiTool, createDataFabricLineTool, createDataFabricMultiLineTool, createDataFabricTableTool, generateEntityFieldsDocs };

package/dist/registry/ai-chat/tools/data-fabric/util/chart-helpers.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { type AggregationKind, type ChartDataModel, type DataModelField, type DataModelFieldType, type DataModelMetric } from "../../../../charts-core/charts-core";
+import { type Entity, type EntityField } from "./entities";
+import { type ResolverResult } from "./resolver-result";
+export declare function buildMetricEntry(metric: ResolvedMetric): DataModelMetric;
+interface BuildDataModelInput<T extends DataModelFieldType> {
+    id: string;
+    dimension: string;
+    dimensionType: T;
+    metric: ResolvedMetric;
+}
+export declare function buildDataModel<T extends DataModelFieldType>({ id, dimension, dimensionType, metric, }: BuildDataModelInput<T>): ChartDataModel<Extract<DataModelField, {
+    type: T;
+}>>;
+interface BuildMultiMetricDataModelInput<T extends DataModelFieldType> {
+    id: string;
+    dimension: string;
+    dimensionType: T;
+    metrics: ResolvedMetric[];
+}
+export declare function buildMultiMetricDataModel<T extends DataModelFieldType>({ id, dimension, dimensionType, metrics, }: BuildMultiMetricDataModelInput<T>): ChartDataModel<Extract<DataModelField, {
+    type: T;
+}>>;
+export declare const metricSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    aggregation: z.ZodLiteral<"COUNT">;
+    field: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    aggregation: z.ZodEnum<{
+        MIN: "MIN";
+        MAX: "MAX";
+        SUM: "SUM";
+        AVG: "AVG";
+    }>;
+    field: z.ZodString;
+}, z.core.$strip>], "aggregation">;
+export type MetricInput = z.infer<typeof metricSchema>;
+export declare function formatAggregation(aggregation: AggregationKind): string;
+export interface ResolvedDimension<T extends DataModelFieldType = DataModelFieldType> {
+    id: string;
+    type: T;
+}
+export interface ResolvedMetric {
+    argument: DataModelField;
+    aggregation: AggregationKind;
+    display: string;
+}
+export declare function dedupeMetrics(metrics: ResolvedMetric[]): ResolvedMetric[];
+export declare function resolveSingleDimension<T extends DataModelFieldType>(entity: Entity, dimension: string, allowed: ReadonlyArray<T>): ResolverResult<ResolvedDimension<T>>;
+export declare function resolveMultiDimension<T extends DataModelFieldType>(primaryEntity: string, dimension: string, qualifiedFields: Map<string, EntityField>, allowed: ReadonlyArray<T>): ResolverResult<ResolvedDimension<T>>;
+export declare function resolveSingleMetric(entity: Entity, metric: MetricInput | undefined): ResolverResult<ResolvedMetric>;
+export declare function resolveMultiMetric(primaryEntity: string, metric: MetricInput | undefined, qualifiedFields: Map<string, EntityField>): ResolverResult<ResolvedMetric>;
+export {};

package/dist/registry/ai-chat/tools/data-fabric/util/chart-helpers.js

@@ -0,0 +1,227 @@
+import { z } from "zod";
+import { buildField } from "../../../../charts-core/charts-core.js";
+import { mapFieldType, pickCountField, pickCountFieldQualified } from "./entities.js";
+import { fail, ok } from "./resolver-result.js";
+function buildMetricEntry(metric) {
+    const aliasField = metric.argument.id.replaceAll(".", "_");
+    return {
+        id: `${metric.aggregation}_${aliasField}`,
+        display: metric.display,
+        expression: {
+            type: "aggregate",
+            aggregation: metric.aggregation,
+            argument: metric.argument
+        }
+    };
+}
+function buildDataModel({ id, dimension, dimensionType, metric }) {
+    return {
+        id,
+        dimensions: [
+            buildField(dimension, dimensionType)
+        ],
+        metrics: [
+            buildMetricEntry(metric)
+        ]
+    };
+}
+function buildMultiMetricDataModel({ id, dimension, dimensionType, metrics }) {
+    return {
+        id,
+        dimensions: [
+            buildField(dimension, dimensionType)
+        ],
+        metrics: metrics.map((m)=>buildMetricEntry(m))
+    };
+}
+const metricSchema = z.discriminatedUnion("aggregation", [
+    z.object({
+        aggregation: z.literal("COUNT"),
+        field: z.string().optional().describe("Field counted per bin. Optional — defaults to the entity primary key.")
+    }),
+    z.object({
+        aggregation: z["enum"]([
+            "SUM",
+            "AVG",
+            "MIN",
+            "MAX"
+        ]),
+        field: z.string().describe("Numeric field aggregated by the metric. Required for SUM/AVG/MIN/MAX.")
+    })
+]).describe("Metric to plot per bin. Omit entirely for the default COUNT of records.");
+function formatAggregation(aggregation) {
+    switch(aggregation){
+        case "COUNT":
+            return "Count";
+        case "SUM":
+            return "Sum";
+        case "AVERAGE":
+            return "Avg";
+        case "MIN":
+            return "Min";
+        case "MAX":
+            return "Max";
+        case "ANY":
+            return "Any";
+        case "DISTINCT_COUNT":
+            return "Distinct count";
+        case "PERCENTAGE":
+            return "Percentage";
+        case "PERCENTILE":
+            return "Percentile";
+        case "MEDIAN":
+            return "Median";
+    }
+}
+function metricInputToAggregateType(input) {
+    switch(input.aggregation){
+        case "COUNT":
+            return "COUNT";
+        case "SUM":
+            return "SUM";
+        case "AVG":
+            return "AVERAGE";
+        case "MIN":
+            return "MIN";
+        case "MAX":
+            return "MAX";
+    }
+}
+function dedupeMetrics(metrics) {
+    const seen = new Set();
+    return metrics.filter((m)=>{
+        const key = `${m.aggregation}|${m.argument.id}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+function isAllowedFieldType(value, allowed) {
+    return allowed.includes(value);
+}
+function resolveSingleDimension(entity, dimension, allowed) {
+    const field = entity.fields.find((f)=>f.name === dimension);
+    if (!field) return fail({
+        reason: "unknown_field_in_entity",
+        field: dimension,
+        entity: entity.name
+    });
+    const type = mapFieldType(field.dataType);
+    if (!isAllowedFieldType(type, allowed)) return fail({
+        reason: "wrong_dimension_type_in_entity",
+        field: dimension,
+        entity: entity.name,
+        actual: field.dataType,
+        expected: allowed.join(" or ")
+    });
+    return ok({
+        id: field.name,
+        type
+    });
+}
+function resolveMultiDimension(primaryEntity, dimension, qualifiedFields, allowed) {
+    const qualified = dimension.includes(".") ? dimension : `${primaryEntity}.${dimension}`;
+    const field = qualifiedFields.get(qualified);
+    if (!field) return fail({
+        reason: "unknown_field_in_joined",
+        field: qualified
+    });
+    const type = mapFieldType(field.dataType);
+    if (!isAllowedFieldType(type, allowed)) return fail({
+        reason: "wrong_dimension_type_in_joined",
+        field: qualified,
+        actual: field.dataType,
+        expected: allowed.join(" or ")
+    });
+    return ok({
+        id: qualified,
+        type
+    });
+}
+function resolveSingleMetric(entity, metric) {
+    if (!metric || "COUNT" === metric.aggregation) {
+        const userField = metric?.field && entity.fields.some((f)=>f.name === metric.field) ? metric.field : null;
+        const fieldName = userField ?? pickCountField(entity);
+        if (!fieldName) return fail({
+            reason: "no_countable_in_entity",
+            entity: entity.name
+        });
+        const entityField = entity.fields.find((f)=>f.name === fieldName);
+        const type = entityField ? mapFieldType(entityField.dataType) : "string";
+        return ok({
+            argument: buildField(fieldName, type),
+            aggregation: "COUNT",
+            display: userField ? `Count of ${userField}` : "Count"
+        });
+    }
+    if (!metric.field) return fail({
+        reason: "missing_metric_field",
+        aggregation: metric.aggregation
+    });
+    const field = entity.fields.find((f)=>f.name === metric.field);
+    if (!field) return fail({
+        reason: "unknown_field_in_entity",
+        field: metric.field,
+        entity: entity.name
+    });
+    if ("number" !== field.dataType) return fail({
+        reason: "wrong_metric_type_in_entity",
+        field: metric.field,
+        entity: entity.name,
+        actual: field.dataType,
+        aggregation: metric.aggregation
+    });
+    const aggregation = metricInputToAggregateType(metric);
+    return ok({
+        argument: buildField(field.name, "numeric"),
+        aggregation,
+        display: `${formatAggregation(aggregation)} of ${field.name}`
+    });
+}
+function unqualifiedDisplay(qualified) {
+    return qualified.split(".").at(-1) ?? qualified;
+}
+function resolveMultiMetric(primaryEntity, metric, qualifiedFields) {
+    if (!metric || "COUNT" === metric.aggregation) {
+        let userField = null;
+        if (metric?.field) {
+            const qualified = metric.field.includes(".") ? metric.field : `${primaryEntity}.${metric.field}`;
+            if (qualifiedFields.has(qualified)) userField = qualified;
+        }
+        const fieldName = userField ?? pickCountFieldQualified(primaryEntity, qualifiedFields);
+        if (!fieldName) return fail({
+            reason: "no_countable_in_joined",
+            primary: primaryEntity
+        });
+        const entityField = qualifiedFields.get(fieldName);
+        const type = entityField ? mapFieldType(entityField.dataType) : "string";
+        return ok({
+            argument: buildField(fieldName, type),
+            aggregation: "COUNT",
+            display: userField ? `Count of ${unqualifiedDisplay(userField)}` : "Count"
+        });
+    }
+    if (!metric.field) return fail({
+        reason: "missing_metric_field",
+        aggregation: metric.aggregation
+    });
+    const qualified = metric.field.includes(".") ? metric.field : `${primaryEntity}.${metric.field}`;
+    const field = qualifiedFields.get(qualified);
+    if (!field) return fail({
+        reason: "unknown_field_in_joined",
+        field: qualified
+    });
+    if ("number" !== field.dataType) return fail({
+        reason: "wrong_metric_type_in_joined",
+        field: qualified,
+        actual: field.dataType,
+        aggregation: metric.aggregation
+    });
+    const aggregation = metricInputToAggregateType(metric);
+    return ok({
+        argument: buildField(qualified, "numeric"),
+        aggregation,
+        display: `${formatAggregation(aggregation)} of ${unqualifiedDisplay(qualified)}`
+    });
+}
+export { buildDataModel, buildMetricEntry, buildMultiMetricDataModel, dedupeMetrics, formatAggregation, metricSchema, resolveMultiDimension, resolveMultiMetric, resolveSingleDimension, resolveSingleMetric };

package/dist/registry/ai-chat/tools/data-fabric/util/entities.d.ts

@@ -0,0 +1,21 @@
+export interface EntityField {
+    name: string;
+    dataType: "string" | "number" | "boolean" | "datetime";
+    isPrimaryKey: boolean;
+    isRequired: boolean;
+}
+export interface Entity {
+    id: string;
+    name: string;
+    fields: readonly EntityField[];
+}
+export interface DataFabricToolContext {
+    entities: Record<string, Entity>;
+    accessToken: string;
+    dataFabricBaseUrl: string;
+}
+export declare function mapFieldType(dataType: EntityField["dataType"]): "string" | "numeric" | "boolean" | "datetime";
+export declare function collectQualifiedFields(entityNames: string[], entities: Record<string, Entity>): Map<string, EntityField>;
+export declare function generateEntityFieldsDocs(entities: Record<string, Entity>): string;
+export declare function pickCountField(entity: Entity): string | null;
+export declare function pickCountFieldQualified(primaryEntity: string, qualifiedFields: Map<string, EntityField>): string | null;

package/dist/registry/ai-chat/tools/data-fabric/util/entities.js

@@ -0,0 +1,44 @@
+function mapFieldType(dataType) {
+    switch(dataType){
+        case "number":
+            return "numeric";
+        case "boolean":
+            return "boolean";
+        case "datetime":
+            return "datetime";
+        case "string":
+            return "string";
+    }
+}
+function collectQualifiedFields(entityNames, entities) {
+    const fields = new Map();
+    for (const name of entityNames){
+        const entity = entities[name];
+        if (entity) for (const field of entity.fields)fields.set(`${name}.${field.name}`, field);
+    }
+    return fields;
+}
+function generateEntityFieldsDocs(entities) {
+    return Object.entries(entities).map(([entityName, entity])=>{
+        const fields = entity.fields.map((field)=>`${field.name} (${field.dataType})`).join(", ");
+        return `${entityName}: ${fields}`;
+    }).join("\n\n");
+}
+function pickCountField(entity) {
+    const pk = entity.fields.find((f)=>f.isPrimaryKey);
+    if (pk) return pk.name;
+    const numeric = entity.fields.find((f)=>"number" === f.dataType);
+    if (numeric) return numeric.name;
+    return entity.fields[0]?.name ?? null;
+}
+function pickCountFieldQualified(primaryEntity, qualifiedFields) {
+    const primaryEntries = [
+        ...qualifiedFields.entries()
+    ].filter(([key])=>key.startsWith(`${primaryEntity}.`));
+    const pk = primaryEntries.find(([, f])=>f.isPrimaryKey);
+    if (pk) return pk[0];
+    const numeric = primaryEntries.find(([, f])=>"number" === f.dataType);
+    if (numeric) return numeric[0];
+    return primaryEntries[0]?.[0] ?? null;
+}
+export { collectQualifiedFields, generateEntityFieldsDocs, mapFieldType, pickCountField, pickCountFieldQualified };

package/dist/registry/ai-chat/tools/data-fabric/util/filters.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import type { TableChartConfiguration } from "../../../../charts-core/charts-core";
+import type { EntityField } from "./entities";
+export declare const filterSchema: 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>]>;
+export type FilterInput = z.infer<typeof filterSchema>;
+export type ResolvedFilter = NonNullable<TableChartConfiguration["filters"]>[number];
+export type ResolveFiltersOptions = {
+    mode: "single";
+    validFields: Iterable<string>;
+} | {
+    mode: "multi";
+    primaryEntity: string;
+    qualifiedFields: Map<string, EntityField>;
+};
+/**
+ * Validate & qualify filter fields, then materialize values (e.g. ISO datetime
+ * strings → luxon `DateTime`). Drops filters referencing unknown or ambiguous
+ * fields, preventing hallucinated fields from reaching the server. Also drops
+ * filters whose values fail to materialize (e.g. unparseable datetime strings).
+ */
+export declare function resolveFilters(filters: FilterInput[] | undefined, options: ResolveFiltersOptions): ResolvedFilter[] | undefined;

package/dist/registry/ai-chat/tools/data-fabric/util/filters.js

@@ -0,0 +1,131 @@
+import { DateTime } from "luxon";
+import { z } from "zod";
+const stringListFilterSchema = z.object({
+    type: z.literal("list"),
+    field: z.string().describe("Field name to filter on"),
+    valueType: z.literal("string"),
+    values: z.array(z.union([
+        z.string(),
+        z["null"]()
+    ])).describe("Values to match"),
+    invert: z.boolean().optional().describe("If true, exclude matching values instead")
+});
+const numberListFilterSchema = z.object({
+    type: z.literal("list"),
+    field: z.string().describe("Field name to filter on"),
+    valueType: z.literal("number"),
+    values: z.array(z.union([
+        z.number(),
+        z["null"]()
+    ])).describe("Values to match"),
+    invert: z.boolean().optional().describe("If true, exclude matching values instead")
+});
+const booleanListFilterSchema = z.object({
+    type: z.literal("list"),
+    field: z.string().describe("Field name to filter on"),
+    valueType: z.literal("boolean"),
+    values: z.array(z.union([
+        z.boolean(),
+        z["null"]()
+    ])).describe("Values to match"),
+    invert: z.boolean().optional().describe("If true, exclude matching values instead")
+});
+const searchFilterSchema = z.object({
+    type: z.literal("search"),
+    field: z.string().describe("String field name to search"),
+    valueType: z.literal("string"),
+    pattern: z.string().describe("Text pattern to match"),
+    searchFilterType: z["enum"]([
+        "default",
+        "startsWith",
+        "endsWith"
+    ]).describe("default = contains")
+});
+const numberRangeFilterSchema = z.object({
+    type: z.literal("range"),
+    field: z.string().describe("Numeric field name"),
+    valueType: z.literal("number"),
+    range: z.union([
+        z.object({
+            min: z.number().describe("Minimum value (inclusive)"),
+            max: z.number().optional().describe("Maximum value (inclusive)"),
+            inclusive: z.boolean().optional()
+        }),
+        z.object({
+            min: z.number().optional().describe("Minimum value (inclusive)"),
+            max: z.number().describe("Maximum value (inclusive)"),
+            inclusive: z.boolean().optional()
+        })
+    ])
+});
+const datetimeRangeFilterSchema = z.object({
+    type: z.literal("range"),
+    field: z.string().describe("Datetime field name"),
+    valueType: z.literal("datetime"),
+    range: z.object({
+        min: z.string().describe("ISO 8601 datetime, inclusive lower bound (e.g. 2026-01-01)"),
+        max: z.string().describe("ISO 8601 datetime, inclusive upper bound (e.g. 2026-12-31)"),
+        inclusive: z.boolean().optional()
+    })
+});
+const filterSchema = z.union([
+    stringListFilterSchema,
+    numberListFilterSchema,
+    booleanListFilterSchema,
+    searchFilterSchema,
+    numberRangeFilterSchema,
+    datetimeRangeFilterSchema
+]).describe("Filter to apply to the query");
+const isQualified = (field)=>field.includes(".");
+function resolveQualifiedField(field, primaryEntity, qualifiedFields) {
+    if (isQualified(field)) return qualifiedFields.has(field) ? field : null;
+    const primary = `${primaryEntity}.${field}`;
+    if (qualifiedFields.has(primary)) return primary;
+    const suffix = `.${field}`;
+    const matches = [
+        ...qualifiedFields.keys()
+    ].filter((k)=>k.endsWith(suffix));
+    return 1 === matches.length ? matches[0] ?? null : null;
+}
+function fieldResolver(options) {
+    if ("single" === options.mode) {
+        const valid = new Set(options.validFields);
+        return (f)=>valid.has(f) ? f : null;
+    }
+    const { primaryEntity, qualifiedFields } = options;
+    return (f)=>resolveQualifiedField(f, primaryEntity, qualifiedFields);
+}
+function materializeFilter(filter) {
+    if ("range" === filter.type && "datetime" === filter.valueType) {
+        const min = DateTime.fromISO(filter.range.min);
+        const max = DateTime.fromISO(filter.range.max);
+        if (!min.isValid || !max.isValid) return null;
+        return {
+            type: "range",
+            valueType: "datetime",
+            field: filter.field,
+            range: {
+                min,
+                max,
+                inclusive: filter.range.inclusive
+            }
+        };
+    }
+    return filter;
+}
+function resolveFilters(filters, options) {
+    if (!filters) return filters;
+    const resolve = fieldResolver(options);
+    return filters.flatMap((f)=>{
+        const field = resolve(f.field);
+        if (!field) return [];
+        const materialized = materializeFilter({
+            ...f,
+            field
+        });
+        return materialized ? [
+            materialized
+        ] : [];
+    });
+}
+export { filterSchema, resolveFilters };

package/dist/registry/ai-chat/tools/data-fabric/util/joins.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const joinSchema: 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>;
+export type JoinInput = z.infer<typeof joinSchema>;

package/dist/registry/ai-chat/tools/data-fabric/util/joins.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const joinSchema = z.object({
+    type: z["enum"]([
+        "INNER",
+        "LEFT"
+    ]).describe("Join type"),
+    entity: z.string().describe("Entity to join"),
+    on: z.object({
+        left: z.string().describe("Field from the primary entity (EntityName.Field format)"),
+        right: z.string().describe("Field from the joined entity (EntityName.Field format)")
+    })
+});
+export { joinSchema };

package/dist/registry/ai-chat/tools/data-fabric/util/resolver-result.d.ts

@@ -0,0 +1,57 @@
+export type ResolverFailure = {
+    reason: "unknown_field_in_entity";
+    field: string;
+    entity: string;
+} | {
+    reason: "unknown_field_in_joined";
+    field: string;
+} | {
+    reason: "wrong_dimension_type_in_entity";
+    field: string;
+    entity: string;
+    actual: string;
+    expected: string;
+} | {
+    reason: "wrong_dimension_type_in_joined";
+    field: string;
+    actual: string;
+    expected: string;
+} | {
+    reason: "wrong_metric_type_in_entity";
+    field: string;
+    entity: string;
+    actual: string;
+    aggregation: string;
+} | {
+    reason: "wrong_metric_type_in_joined";
+    field: string;
+    actual: string;
+    aggregation: string;
+} | {
+    reason: "missing_metric_field";
+    aggregation: string;
+} | {
+    reason: "no_countable_in_entity";
+    entity: string;
+} | {
+    reason: "no_countable_in_joined";
+    primary: string;
+};
+export type ToolResolutionFailure = {
+    reason: "unknown_entity";
+    entity: string;
+} | {
+    reason: "table_no_valid_fields";
+    entity: string;
+    fields: string;
+} | {
+    reason: "multi_line_too_few_metrics";
+} | ResolverFailure;
+export type ResolverResult<T> = {
+    ok: true;
+    value: T;
+} | ({
+    ok: false;
+} & ResolverFailure);
+export declare const ok: <T>(value: T) => ResolverResult<T>;
+export declare const fail: <T>(failure: ResolverFailure) => ResolverResult<T>;

package/dist/registry/ai-chat/tools/data-fabric/util/resolver-result.js

@@ -0,0 +1,9 @@
+const ok = (value)=>({
+        ok: true,
+        value
+    });
+const fail = (failure)=>({
+        ok: false,
+        ...failure
+    });
+export { fail, ok };