@genesislcap/ai-assistant 15.34.1 → 15.35.0

package/dist/esm/genesis/criteria.js

@@ -0,0 +1,426 @@
+/**
+ * Criteria composition for the Genesis read tools.
+ *
+ * @remarks
+ * **The model never writes a criteria expression, and this is the reason.** Criteria are parsed
+ * as Groovy on the server, and the platform composes an app's row-level restriction into the
+ * same string: `"($userCriteria) && ($criteriaTemplate)"`. A criteria string authored from model
+ * output could therefore `||` its way past the restriction that decides which rows a user is
+ * allowed to see. So the tool takes STRUCTURED filters — field, op, value — validated against
+ * the fields the platform itself reports as filterable, and this module builds the expression.
+ * Anything it cannot build is refused outright: never a partial expression, never a silent drop.
+ *
+ * Do not "simplify" this into a free-text criteria parameter.
+ *
+ * The grammar and escaping match the platform's other structured-filter caller, grid-pro's
+ * `filter.utils.ts`, so the bridge is not a second dialect of the same expression language.
+ */
+/**
+ * Genesis field types, EXACTLY matched — copied from
+ * `foundation-ui/src/ai-criteria-search/validation/schema-validator.ts`, which puts the reason
+ * plainly: "exact match to avoid false positives (e.g. STATUS containing INT)". A prefix test
+ * also mistakes `NANO_TIMESTAMP` and `LOCALDATETIME` for text, which quotes a string against a
+ * timestamp column and silently returns nothing. The sets are module-private there, so they are
+ * copied rather than imported, and pinned by a test.
+ */
+const DATE_TYPES = new Set(['DATE', 'LOCALDATE']);
+const DATETIME_TYPES = new Set(['DATETIME', 'NANO_TIMESTAMP', 'LOCALDATETIME', 'TIMESTAMP']);
+const NUMBER_TYPES = new Set([
+    'INT',
+    'INTEGER',
+    'LONG',
+    'SHORT',
+    'DOUBLE',
+    'BIGDECIMAL',
+    'DECIMAL',
+]);
+/** `STRING(256)` and `BIGDECIMAL(10,3)` carry their parameters; the set holds the bare name. */
+const normaliseType = (fieldType) => String(fieldType !== null && fieldType !== void 0 ? fieldType : '')
+    .toUpperCase()
+    .trim()
+    .split('(')[0]
+    .trim();
+const OPS_BY_KIND = {
+    string: ['equals', 'not_equals', 'contains', 'is_blank', 'is_not_blank'],
+    number: [
+        'equals',
+        'not_equals',
+        'greater_than',
+        'greater_or_equal',
+        'less_than',
+        'less_or_equal',
+        'is_blank',
+        'is_not_blank',
+    ],
+    boolean: ['equals', 'not_equals', 'is_blank', 'is_not_blank'],
+    date: [
+        'equals',
+        'greater_than',
+        'greater_or_equal',
+        'less_than',
+        'less_or_equal',
+        'is_blank',
+        'is_not_blank',
+    ],
+    // No equality: a timestamp is almost never exactly equal to a value a model would write, and
+    // the platform's own datetime operator list offers none either (foundation-ui operator-map).
+    datetime: ['greater_or_equal', 'less_or_equal', 'is_blank', 'is_not_blank'],
+};
+/** @internal */
+export function fieldKindOf(type) {
+    const normalised = normaliseType(type);
+    if (DATE_TYPES.has(normalised))
+        return 'date';
+    if (DATETIME_TYPES.has(normalised))
+        return 'datetime';
+    if (NUMBER_TYPES.has(normalised))
+        return 'number';
+    if (normalised === 'BOOLEAN')
+        return 'boolean';
+    return 'string';
+}
+/**
+ * Escapes a value for a criteria string literal: backslashes first, then quotes. An unescaped
+ * quote would close the literal early — which is the injection this module exists to prevent —
+ * and a trailing backslash would escape the closing quote instead.
+ */
+const escape = (value) => String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+/**
+ * The inclusive range each part of a date or time bound may take. A part outside it reaches the
+ * server as a criteria it cannot evaluate, and the read path deliberately hides the compiler's
+ * answer from the model — so the explanation is produced here or nowhere.
+ */
+const BOUND_LIMITS = {
+    month: { min: 1, max: 12 },
+    day: { min: 1, max: 31 },
+    hour: { min: 0, max: 23 },
+    minute: { min: 0, max: 59 },
+    second: { min: 0, max: 59 },
+};
+/** Whether a captured part is within its limits. An absent part is not out of range. */
+const inRange = (text, part) => {
+    if (text === undefined)
+        return true;
+    const { min, max } = BOUND_LIMITS[part];
+    const value = Number(text);
+    return value >= min && value <= max;
+};
+/**
+ * `2026-09-21` to the `yyyyMMdd` form the platform's `Expr.dateIs*` helpers take. Anchored at
+ * both ends: trailing characters mean the model meant something this does not handle, and
+ * silently keeping the first eight digits would filter on a date nobody asked for.
+ *
+ * The month and day are range-checked because an impossible one reaches the server as a criteria
+ * it cannot evaluate, and the model is then told "that filter was not accepted by the app" with
+ * no way to tell which part of it was wrong — the read path deliberately hides the compiler's
+ * answer, so the explanation has to be produced here or nowhere.
+ */
+function toPlatformDate(value) {
+    const match = /^(\d{4})-?(\d{2})-?(\d{2})$/.exec(String(value).trim());
+    if (!match || !inRange(match[2], 'month') || !inRange(match[3], 'day'))
+        return undefined;
+    return `${match[1]}${match[2]}${match[3]}`;
+}
+/**
+ * The `yyyyMMdd-HH:mm:ss` bound the `Expr.dateTimeIs*` helpers take, filled out to the END of
+ * whatever precision the model expressed for an upper bound and to its START for a lower one.
+ *
+ * @remarks
+ * **Defaulting both bounds to `00:00` loses a whole day, silently.** `CREATED_AT less_or_equal
+ * '2026-09-21'` composed `Expr.dateTimeIsLessEqual(CREATED_AT, '20260921-00:00')`, which is
+ * valid Groovy, compiles, and matches only a row stored exactly at midnight — so "on or before
+ * the 21st" returned almost nothing and reported it as an empty result. Reviewer catch on #2543.
+ *
+ * One rule covers every precision rather than special-casing the bare date: an inclusive upper
+ * bound runs to the end of the unit the model named (a day, a minute, a second) and a lower
+ * bound to its start. A supplied time is never widened — `'2026-09-21T14:30'` as an upper bound
+ * means through 14:30:59, not through the end of the day.
+ *
+ * **Seconds, not milliseconds.** `foundation-ui`'s own date filter emits `'20211013-00:00:00'`
+ * into these helpers (`filter.ts`, `toISOString().slice(0, 19)`), so seconds are the precision
+ * proven to work; nothing in the monorepo sends millis, and a bound shape the parser does not
+ * take fails a real user's read rather than a test. The residual gap is therefore under one
+ * second at the top of a range, and closing it needs one live capture of a `.SSS` bound.
+ *
+ * Milliseconds on the way IN are refused rather than truncated: dropping them narrows an upper
+ * bound and widens a lower one, which is the same silent-day bug one unit down.
+ */
+function toPlatformDateTime(value, bound) {
+    const match = /^(\d{4})-?(\d{2})-?(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2}))?)?$/.exec(String(value).trim());
+    if (!match)
+        return undefined;
+    const [, year, month, day, hour, minute, second] = match;
+    if (!inRange(month, 'month') || !inRange(day, 'day'))
+        return undefined;
+    if (!inRange(hour, 'hour') || !inRange(minute, 'minute') || !inRange(second, 'second')) {
+        return undefined;
+    }
+    const fill = bound === 'end';
+    return (`${year}${month}${day}-${hour !== null && hour !== void 0 ? hour : (fill ? '23' : '00')}` +
+        `:${minute !== null && minute !== void 0 ? minute : (fill ? '59' : '00')}:${second !== null && second !== void 0 ? second : (fill ? '59' : '00')}`);
+}
+/**
+ * Each fragment builder answers only for the ops it knows, and `undefined` otherwise.
+ *
+ * @remarks
+ * These used to end in a `default:` that returned one operator — `containsIgnoreCase` for a
+ * string, `dateIsLessEqual` for a date — so an op added to {@link OPS_BY_KIND} without a fragment
+ * would have been composed silently as that one, filtering on something nobody asked for. The
+ * allow-list makes it unreachable today; this makes it impossible tomorrow, which is the same
+ * argument the operator Map is built on. Exported so that property can be tested at all — the
+ * allow-list is what stops `composeCriteria` reaching it.
+ *
+ * @internal
+ */
+export function stringFragment(field, op, value) {
+    switch (op) {
+        case 'equals':
+            return `${field} == '${escape(value)}'`;
+        case 'not_equals':
+            return `${field} != '${escape(value)}'`;
+        case 'contains':
+            return `Expr.containsIgnoreCase(${field}, '${escape(value)}')`;
+        default:
+            return undefined;
+    }
+}
+// A Map, not an object: this is the one position where model input chooses an OPERATOR, and a
+// bare lookup would find `constructor` and friends on Object.prototype. The op allow-list above
+// already blocks that; this makes it impossible rather than merely unreachable.
+const NUMBER_OPERATORS = new Map([
+    ['equals', '=='],
+    ['not_equals', '!='],
+    ['greater_than', '>'],
+    ['greater_or_equal', '>='],
+    ['less_than', '<'],
+    ['less_or_equal', '<='],
+]);
+export function dateFragment(field, op, date) {
+    switch (op) {
+        case 'equals':
+            return `Expr.dateIsEqual(${field}, '${date}')`;
+        case 'greater_than':
+            return `Expr.dateIsAfter(${field}, '${date}')`;
+        case 'less_than':
+            return `Expr.dateIsBefore(${field}, '${date}')`;
+        case 'greater_or_equal':
+            return `Expr.dateIsGreaterEqual(${field}, '${date}')`;
+        case 'less_or_equal':
+            return `Expr.dateIsLessEqual(${field}, '${date}')`;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Timestamp columns get the dateTime helpers, which take a `yyyyMMdd-HH:mm:ss` bound.
+ *
+ * @remarks
+ * There is no strictly-before helper to reach for: `dateTimeIsBefore` maps to
+ * `dateTimeIsLessEqual` (foundation-ui's operator-map), and a negated
+ * `!Expr.dateTimeIsGreaterEqual(...)` would pull rows with a NULL timestamp INTO the match set,
+ * because the comparison is false for null. So the bound itself carries the inclusivity — see
+ * {@link toPlatformDateTime}.
+ */
+export function dateTimeFragment(field, op, bound) {
+    if (op === 'greater_or_equal')
+        return `Expr.dateTimeIsGreaterEqual(${field}, '${bound}')`;
+    return op === 'less_or_equal' ? `Expr.dateTimeIsLessEqual(${field}, '${bound}')` : undefined;
+}
+/** A value being absent is not the same as being empty, except for strings, where both count. */
+function blankFragment(field, kind, negated) {
+    if (kind !== 'string')
+        return `${field} ${negated ? '!=' : '=='} null`;
+    return negated ? `(${field} != '' && ${field} != null)` : `(${field} == '' || ${field} == null)`;
+}
+/**
+ * What one filter value, and one whole expression, may cost.
+ *
+ * @remarks
+ * Bounding the NUMBER of filters is not the bound that matters: one filter with a 200,000
+ * character value composes a 200KB expression, and the number path accepts it by design — the
+ * digits-only pattern carries them through verbatim precisely so a BIGDECIMAL beyond double
+ * precision is not rounded, and `'9'.repeat(200000)` is all digits.
+ *
+ * The expensive part is not the server's. A rejection reason echoes the offending value, so a
+ * 200KB value produced a 200KB reason, which lands in the tool result, is stringified into the
+ * transcript, and is billed again as input on every later turn of the conversation — from the
+ * path that is supposed to be the safe one. Rows are stamped untrusted because other users
+ * wrote them, so a row carrying text that steers the model into copying a long string is a real
+ * route in. Cost and stability rather than privilege: the grammar holds either way.
+ *
+ * So the length is bounded, and checked BEFORE any rejection that interpolates the value.
+ * Reviewer catch on #2543, with a different quantity: his `maxItems` bounds the count, which
+ * permits ten times the expression he demonstrated.
+ */
+const MAX_VALUE_LENGTH = 512;
+const MAX_CRITERIA_LENGTH = 4096;
+/** Everything below SPACE, and DEL: the characters an expression cannot carry. */
+const FIRST_PRINTABLE_CODE = 0x20;
+const DELETE_CODE = 0x7f;
+/** A line break or other control character — checked by code point, not by a control regex. */
+function hasControlCharacter(text) {
+    for (const character of text) {
+        const code = character.codePointAt(0);
+        if (code !== undefined && (code < FIRST_PRINTABLE_CODE || code === DELETE_CODE))
+            return true;
+    }
+    return false;
+}
+/**
+ * A fragment, or a refusal if the builder had no expression for that op — which can only happen
+ * if an op joins {@link OPS_BY_KIND} without one, and is a bug here rather than a bad filter.
+ */
+function composed(field, op, criteria) {
+    return criteria
+        ? { status: 'ok', criteria }
+        : { status: 'rejected', reason: `'${op}' cannot be applied to ${field.name}.` };
+}
+function fragmentFor(filter, field) {
+    var _a;
+    const kind = fieldKindOf(field.type);
+    const allowed = OPS_BY_KIND[kind];
+    if (!allowed.includes(filter.op)) {
+        return {
+            status: 'rejected',
+            reason: `${field.name} is a ${kind} field, so '${filter.op}' does not apply to it. Use one of: ${allowed.join(', ')}.`,
+        };
+    }
+    if (filter.op === 'is_blank' || filter.op === 'is_not_blank') {
+        return {
+            status: 'ok',
+            criteria: blankFragment(field.name, kind, filter.op === 'is_not_blank'),
+        };
+    }
+    if (filter.value === undefined || filter.value === null || filter.value === '') {
+        return { status: 'rejected', reason: `the filter on ${field.name} has no value.` };
+    }
+    // Before the checks below, every one of which interpolates the value into its reason: a guard
+    // placed after them leaves the amplification it exists to prevent wide open. The reason here
+    // names the LENGTH and never the value, for the same reason.
+    const length = String(filter.value).length;
+    if (length > MAX_VALUE_LENGTH) {
+        return {
+            status: 'rejected',
+            reason: `the value for ${field.name} is ${length} characters. A filter value may be up to ${MAX_VALUE_LENGTH}.`,
+        };
+    }
+    if ((_a = field.validValues) === null || _a === void 0 ? void 0 : _a.length) {
+        const value = String(filter.value);
+        if (!field.validValues.includes(value)) {
+            return {
+                status: 'rejected',
+                reason: `${value} is not a value ${field.name} can hold. It is one of: ${field.validValues.join(', ')}.`,
+            };
+        }
+    }
+    // A newline or other control character escapes cleanly but leaves an expression the server's
+    // Groovy parser rejects, so the read fails there instead of here, with a compiler error the
+    // model cannot act on. Refused with a reason it can.
+    if (typeof filter.value === 'string' && hasControlCharacter(filter.value)) {
+        return {
+            status: 'rejected',
+            reason: `the value for ${field.name} contains a line break or control character.`,
+        };
+    }
+    switch (kind) {
+        case 'number': {
+            // The digits are carried through verbatim rather than via Number(): a LONG or BIGDECIMAL
+            // beyond double precision would otherwise be rounded INTO the expression, and the model
+            // would be told about rows that were never matched. The pattern is the validation — only
+            // digits, one optional sign and one optional point reach the expression.
+            const text = String(filter.value).trim();
+            if (!/^[-+]?\d+(?:\.\d+)?$/.test(text)) {
+                return {
+                    status: 'rejected',
+                    reason: `${field.name} is a number, and '${String(filter.value)}' is not one.`,
+                };
+            }
+            return { status: 'ok', criteria: `${field.name} ${NUMBER_OPERATORS.get(filter.op)} ${text}` };
+        }
+        case 'boolean': {
+            const text = String(filter.value).toLowerCase();
+            if (text !== 'true' && text !== 'false') {
+                return {
+                    status: 'rejected',
+                    reason: `${field.name} is true or false, and '${String(filter.value)}' is neither.`,
+                };
+            }
+            return {
+                status: 'ok',
+                criteria: `${field.name} ${filter.op === 'equals' ? '==' : '!='} ${text}`,
+            };
+        }
+        case 'datetime': {
+            // An inclusive upper bound runs to the end of the unit the model named; a lower bound to
+            // its start. `less_or_equal` is the only upper-bound op a timestamp takes.
+            const bound = toPlatformDateTime(filter.value, filter.op === 'less_or_equal' ? 'end' : 'start');
+            if (!bound) {
+                return {
+                    status: 'rejected',
+                    reason: `${field.name} is a timestamp, and '${String(filter.value)}' is not one. Use YYYY-MM-DD, YYYY-MM-DDTHH:MM or YYYY-MM-DDTHH:MM:SS.`,
+                };
+            }
+            return composed(field, filter.op, dateTimeFragment(field.name, filter.op, bound));
+        }
+        case 'date': {
+            const date = toPlatformDate(filter.value);
+            if (!date) {
+                return {
+                    status: 'rejected',
+                    reason: `${field.name} is a date, and '${String(filter.value)}' is not one. Use YYYY-MM-DD.`,
+                };
+            }
+            return composed(field, filter.op, dateFragment(field.name, filter.op, date));
+        }
+        default:
+            return composed(field, filter.op, stringFragment(field.name, filter.op, filter.value));
+    }
+}
+/**
+ * Builds one `CRITERIA_MATCH` expression from structured filters, or refuses.
+ *
+ * @remarks
+ * Fragments are parenthesised before they are joined with `&&`, because `&&` binds tighter than
+ * `||`: an unparenthesised `a == '' || a == null` fragment would otherwise let rows through that
+ * the following filters exclude.
+ *
+ * @internal
+ */
+export function composeCriteria(filters, fields) {
+    if (filters === undefined || filters === null)
+        return { status: 'ok' };
+    if (!Array.isArray(filters)) {
+        return { status: 'rejected', reason: 'filters must be a list of {field, op, value} entries.' };
+    }
+    const fragments = [];
+    for (const entry of filters) {
+        const filter = entry;
+        if (!filter || typeof filter.field !== 'string') {
+            return { status: 'rejected', reason: 'every filter needs a field name.' };
+        }
+        const field = fields.get(filter.field);
+        if (!field) {
+            const known = [...fields.keys()];
+            return {
+                status: 'rejected',
+                reason: known.length
+                    ? `${filter.field} cannot be filtered on. The fields that can are: ${known.join(', ')}.`
+                    : `${filter.field} cannot be filtered on: this resource reports no filterable fields.`,
+            };
+        }
+        const fragment = fragmentFor(filter, field);
+        if (fragment.status === 'rejected')
+            return fragment;
+        fragments.push(`(${fragment.criteria})`);
+    }
+    const criteria = fragments.length ? fragments.join(' && ') : undefined;
+    // The whole expression, not just each value: a hundred filters inside the per-value limit
+    // still compose something no read should send.
+    if (criteria && criteria.length > MAX_CRITERIA_LENGTH) {
+        return {
+            status: 'rejected',
+            reason: `those ${fragments.length} filters compose an expression of ${criteria.length} characters, and ${MAX_CRITERIA_LENGTH} is the most a read may send. Use fewer conditions.`,
+        };
+    }
+    return { status: 'ok', criteria };
+}

package/dist/esm/genesis/filter-fields.js

@@ -0,0 +1,124 @@
+import { __awaiter } from "tslib";
+import { logger } from '../utils/logger';
+import { withTimeout } from '../utils/with-timeout';
+/**
+ * A metadata request that never settles would pin the tool list for the page: Connect drops
+ * pending handlers on reconnect (`cleanMessages`) without rejecting them, so the await would
+ * hang forever and the assistant would silently stop listing tools. A timeout turns that into
+ * an ordinary transient failure, retried on the next turn.
+ */
+const METADATA_TIMEOUT_MS = 20000;
+/**
+ * An enum's values. A live 8.15 request server sends them as an array
+ * (`VALID_VALUES: ["SELL", "BUY"]`), while grid-pro's enum filter reads a pipe-separated string,
+ * so both shapes are in use and both are accepted. Getting this wrong is silent: the model is
+ * simply never told what the field can hold.
+ */
+const validValuesOf = (detail) => {
+    const values = detail.VALID_VALUES;
+    if (Array.isArray(values)) {
+        const strings = values.filter((v) => typeof v === 'string' || typeof v === 'number');
+        return strings.length ? strings.map(String) : undefined;
+    }
+    return typeof values === 'string' && values.length ? values.split('|') : undefined;
+};
+/**
+ * The metadata name of a resource: `REQ_TRADE` is read as `REQ_TRADE`, but its metadata and
+ * schema are published under `TRADE`. Asking for the prefixed name answers
+ * "Resource REQ_TRADE is not mapped to a service" (404), which would leave every tool
+ * unfilterable — verified against a live 8.15 router.
+ *
+ * @internal
+ */
+export const metadataNameOf = (resourceName) => resourceName.replace(/^REQ_/, '');
+/** @internal */
+export function filterFieldsFrom(metadata) {
+    var _a, _b, _c;
+    const details = new Map();
+    for (const detail of [...((_a = metadata.REPLY_FIELD) !== null && _a !== void 0 ? _a : []), ...((_b = metadata.FIELD) !== null && _b !== void 0 ? _b : [])]) {
+        if ((detail === null || detail === void 0 ? void 0 : detail.NAME) && !details.has(detail.NAME))
+            details.set(detail.NAME, detail);
+    }
+    // CRITERIA_FIELDS when the resource publishes one. A request server usually does not — it
+    // sends REPLY_FIELD only — and criteria there are evaluated against the row, so every reply
+    // field can be filtered on. (Live check: a criteria on a reply field that is not a request
+    // field filtered correctly, and an undeclared name came back as
+    // "Variable NOPE is not allowed in criteria expression".)
+    const criteriaFields = Array.isArray(metadata.CRITERIA_FIELDS) && metadata.CRITERIA_FIELDS.length
+        ? metadata.CRITERIA_FIELDS
+        : [...details.keys()];
+    const fields = new Map();
+    const undescribed = [];
+    for (const name of criteriaFields) {
+        const detail = details.get(name);
+        // A criteria field the reply describes nowhere is LEFT OUT rather than guessed at. Calling
+        // it STRING was the guess, and it is wrong in both directions, silently: `AMOUNT == '100'`
+        // against a numeric column quotes a string at a number and matches nothing (this module's
+        // own header says the same about a timestamp), while `greater_than` on it is refused with a
+        // confident, wrong explanation — "AMOUNT is a string field" — that the model will act on by
+        // rewording the query for ever.
+        //
+        // The cost is real: a criteria-only request server publishes CRITERIA_FIELDS for every
+        // column of the table, so a field its reply does not carry is ordinary rather than exotic,
+        // and dropping it means the model reads more rows and narrows them itself. That is a slower
+        // right answer, and the alternative is a fast wrong one with nothing to notice it by.
+        if (!detail) {
+            undescribed.push(name);
+            continue;
+        }
+        fields.set(name, { name, type: (_c = detail.TYPE) !== null && _c !== void 0 ? _c : 'STRING', validValues: validValuesOf(detail) });
+    }
+    return { fields, undescribed };
+}
+/**
+ * Fetches a resource's filterable fields. Never throws.
+ *
+ * @remarks
+ * `transient` says whether asking again can help: a request that failed while the app was
+ * disconnected can, but a reply that came back unusable cannot — Connect caches any non-empty
+ * metadata reply for the session, so the same answer would come back without reaching the server.
+ *
+ * @internal
+ */
+export function loadFilterFields(connect_1, resourceName_1) {
+    return __awaiter(this, arguments, void 0, function* (connect, resourceName, timeoutMs = METADATA_TIMEOUT_MS) {
+        let metadata;
+        try {
+            metadata = yield withTimeout(connect.getMetadata(metadataNameOf(resourceName)), timeoutMs);
+        }
+        catch (error) {
+            // Classified by OUTCOME, not by the connection state before the await: a request that was
+            // sent while connected and failed mid-flight is exactly the case worth retrying.
+            return {
+                status: 'failed',
+                reason: `the metadata request failed (${String(error)})`,
+                transient: true,
+            };
+        }
+        if (!metadata || typeof metadata !== 'object' || metadata.ERROR) {
+            // A reply came back and was unusable. Connect caches any non-empty metadata reply for the
+            // session, errors included, so asking again returns the same answer without reaching the
+            // server: settle rather than retry.
+            return {
+                status: 'failed',
+                reason: (metadata === null || metadata === void 0 ? void 0 : metadata.ERROR)
+                    ? `the app refused its metadata (${metadata.ERROR})`
+                    : 'the app returned no usable metadata for it',
+                transient: !metadata,
+            };
+        }
+        const { fields, undescribed } = filterFieldsFrom(metadata);
+        if (undescribed.length) {
+            logger.warn(`Genesis assistant: ${resourceName} lists ${undescribed.join(', ')} as criteria fields but ` +
+                'describes neither type, so they are not offered as filters. Publish them in the ' +
+                "resource's reply fields to make them filterable.");
+        }
+        // Whether the reply DESCRIBED any fields at all, so the caller can tell "this resource has
+        // nothing to filter on" from "we asked in the wrong place, or the platform sent nothing".
+        // Presence of the keys, not their length: a resource that answers with empty lists HAS
+        // described itself — it has nothing to filter on — while a reply that mentions none of them
+        // has described nothing, which is a different thing to tell the host.
+        const published = ['CRITERIA_FIELDS', 'REPLY_FIELD', 'FIELD'].some((key) => key in metadata);
+        return { status: 'ok', fields, published };
+    });
+}

package/dist/esm/genesis/index.js

@@ -0,0 +1,15 @@
+/**
+ * The Genesis bridge for the AI assistant (`@genesislcap/ai-assistant/genesis`).
+ *
+ * Its own entry point, deliberately not re-exported from the package root: it depends on
+ * `@genesislcap/foundation-comms`, and this package declares no `sideEffects`, so anything
+ * exported from the root lands in every consumer's bundle — including hosts that are not
+ * Genesis apps. foundation-comms is an optional peer dependency, so the bridge always resolves
+ * the app's own `Connect` rather than a second copy with a different DI token.
+ *
+ * @packageDocumentation
+ * @beta
+ */
+export { GENESIS_AGENT_NAME, registerGenesisAssistant } from './register-genesis-assistant';
+export { createGenesisResourceTools, GENESIS_DATA_SOURCE } from './resource-tools';
+export { GENESIS_EVENT_OPS } from './types';