@wrenai/genbi 0.0.1

package/dist-server/server/enrichment-verify.js

@@ -0,0 +1,290 @@
+/**
+ * Refutes an enrichment proposal before a human is asked to approve it.
+ *
+ * Everything capable of refuting a proposal — `wren context validate`, `wren
+ * context build`, planning its references through the MDL — used to run inside
+ * apply, downstream of the approval. So the person was asked to approve
+ * something no machine had checked, and the machine checked it afterwards.
+ * That ordering does not scale: enrichment output is routinely larger than
+ * anyone will read, so approval degrades into a rubber stamp — which is worse
+ * than no gate, because it looks like review happened.
+ *
+ * The checks here need no correct answer to compare against. The engine is the
+ * ground truth: a measure over a column that does not exist cannot be planned,
+ * whatever anyone believes about it.
+ *
+ * MECHANISM. A proposal is not on disk, and must not be written into the bound
+ * project to find out whether it is sound. The host copies the project to a
+ * temporary directory, writes the proposal there, runs the ladder, and discards
+ * the copy. The bound project is never touched, so there is nothing to roll
+ * back — not even when a check throws.
+ *
+ * The shadow is host-owned. Giving the agent write access to a project copy is
+ * giving it write access that can leak to the real one.
+ *
+ * WHY THE HOST RUNS THESE ITSELF. The agent holds read-only execution and can
+ * run the same commands; it should, because doing so reduces the rounds needed
+ * here. But its report is not evidence. "The model says validate passed" is the
+ * same failure as the model-authored hashes a live draft once produced, which
+ * is why proposal hashing is host-owned too.
+ */
+import { execFile } from "node:child_process";
+import { cp, lstat, mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+export const VERIFICATION_LADDER = ["sink", "grammar", "validate", "build", "dry_plan", "dry_run"];
+/**
+ * The Wren keys each change kind's draft must be written in. The first live
+ * draft to reach this stage used `model`/`columns`/`metrics`/`relationships` —
+ * plausible-looking, and not Wren's grammar at all.
+ */
+const REQUIRED_KEYS = {
+    new_cube: ["base_object"],
+    new_view: ["statement"],
+};
+/** Keys that indicate a different product's grammar rather than Wren's. */
+const FOREIGN_KEYS = {
+    new_cube: ["columns", "metrics", "model"],
+};
+/**
+ * The first path component of `sink` that is a symlink, if any. Checked inside
+ * the shadow, where `cp` has already reproduced the bound project's own links.
+ */
+async function symlinkComponent(root, sink) {
+    const parts = sink.split("/").filter((part) => part.length > 0);
+    let current = root;
+    for (const part of parts) {
+        current = path.join(current, part);
+        try {
+            if ((await lstat(current)).isSymbolicLink())
+                return path.relative(root, current);
+        }
+        catch {
+            return undefined; // does not exist yet — nothing to follow
+        }
+    }
+    return undefined;
+}
+/**
+ * Every call below runs with `cwd` set to the shadow copy, but `wren` does
+ * not resolve its project from cwd alone: `WREN_PROJECT_HOME`, when set,
+ * wins over cwd-based discovery (see `discover_project_path()` in
+ * `core/wren/src/wren/context.py`), and an explicit `--mdl`/`--path` would
+ * win over both. If this process's own ambient environment ever carries
+ * `WREN_PROJECT_HOME` — as GenBI itself sets it for native session children
+ * (`server/native-sessions.ts`, `server/bin.ts`) — every step below would
+ * silently validate/build/query the BOUND project instead of the shadow,
+ * because `execFile` inherits the parent's env by default. Pin it here,
+ * explicitly, to the one project this call is actually allowed to touch:
+ * the shadow root passed in as `cwd`. This does not depend on whether the
+ * BFF happens to run with `WREN_PROJECT_HOME` unset today.
+ *
+ * `WREN_HOME` (the `~/.wren` profile/config store, a different variable) is
+ * deliberately left ambient rather than pinned: it is a read-only source of
+ * real connection credentials, and `dry-run`/`cube query` need the real
+ * profile to reach the real data source for the warehouse step — pointing
+ * it at a throwaway location would break verification, not sandbox it, and
+ * nothing in this ladder writes through it. Checked: `context validate`,
+ * `context build`, `dry-plan`, `cube query --sql-only`, and `dry-run` take
+ * no other ambient project-selecting input than `WREN_PROJECT_HOME`/cwd/
+ * `~/.wren/config.yml`'s `default_project` (per the CLI's own `--path`
+ * help text and `discover_project_path()`), and none of the five writes to
+ * `WREN_HOME` or any other location outside the project directory it is
+ * given.
+ */
+function runWren(args, cwd) {
+    return new Promise((resolve) => {
+        execFile("wren", args, { cwd, maxBuffer: 32 * 1024 * 1024, env: { ...process.env, WREN_PROJECT_HOME: cwd } }, (error, stdout, stderr) => {
+            resolve({ stdout, stderr, error: error });
+        });
+    });
+}
+/** Trims a command's output into something safe and readable to carry in a verdict. */
+function firstMeaningfulLine(...streams) {
+    for (const stream of streams) {
+        const line = stream
+            .split(/\r?\n/)
+            .map((entry) => entry.trim())
+            .find((entry) => entry.length > 0);
+        if (line !== undefined)
+            return line.slice(0, 400);
+    }
+    return "no output";
+}
+/**
+ * A cheap structural read of a YAML draft. Not a YAML parser: it only needs to
+ * know which top-level keys are present, and pulling in a parser to answer that
+ * would be most of a dependency spent on one question. Matches this package's
+ * existing convention of small single-purpose scans (see `server/adopt.ts`).
+ */
+function topLevelKeys(draft) {
+    const keys = new Set();
+    for (const line of draft.split(/\r?\n/)) {
+        const match = /^([A-Za-z_][\w-]*):/.exec(line);
+        if (match)
+            keys.add(match[1].toLowerCase());
+    }
+    return keys;
+}
+function checkGrammar(operation) {
+    const keys = topLevelKeys(operation.draft);
+    if (keys.size === 0)
+        return undefined; // not a keyed document (e.g. knowledge markdown)
+    const foreign = (FOREIGN_KEYS[operation.changeKind] ?? []).filter((key) => keys.has(key));
+    if (foreign.length > 0) {
+        return `uses ${foreign.map((key) => `"${key}"`).join(", ")}, which is not Wren's grammar for ${operation.changeKind}; expected ${(REQUIRED_KEYS[operation.changeKind] ?? []).map((key) => `"${key}"`).join(", ")}`;
+    }
+    const missing = (REQUIRED_KEYS[operation.changeKind] ?? []).filter((key) => !keys.has(key));
+    return missing.length > 0 ? `is missing required ${missing.map((key) => `"${key}"`).join(", ")} for ${operation.changeKind}` : undefined;
+}
+/** Measure names declared in a cube draft, for the generated query. */
+function draftMeasureNames(draft) {
+    const names = [];
+    let inMeasures = false;
+    for (const line of draft.split(/\r?\n/)) {
+        if (/^measures:\s*$/.test(line)) {
+            inMeasures = true;
+            continue;
+        }
+        if (/^[A-Za-z_]/.test(line)) {
+            inMeasures = false;
+            continue;
+        }
+        if (!inMeasures)
+            continue;
+        const name = /^\s*-?\s*name:\s*"?([A-Za-z_][\w-]*)"?\s*$/.exec(line)?.[1];
+        if (name !== undefined)
+            names.push(name);
+    }
+    return names;
+}
+function probeFor(operation) {
+    const name = /^(?:cubes|views|models)\/([a-z0-9_-]+)\//.exec(operation.sink)?.[1];
+    if (name === undefined)
+        return undefined;
+    if (operation.changeKind === "new_cube") {
+        const measures = draftMeasureNames(operation.draft);
+        return measures.length > 0 ? { kind: "cube", cube: name, measures } : undefined;
+    }
+    return { kind: "relation", sql: `SELECT * FROM "${name}" LIMIT 0` };
+}
+/**
+ * There is deliberately no opt-out for the data-source step.
+ *
+ * An earlier version carried an `includeWarehouseDryRun` flag documented as
+ * "off by default". Once cubes had to be checked through `dry-run` — nothing
+ * local resolves their expressions — the flag stopped being read while its
+ * documentation went on promising a round trip could be avoided. An advertised
+ * safety lever that does nothing is worse than none, so it is gone.
+ *
+ * What is true, in one place: verifying a `new_cube` always reaches the data
+ * source, via `dry-run`, which parses and validates without returning rows.
+ * Every other change kind is verified entirely locally. A caller that cannot
+ * reach its source cannot verify a cube, and the honest report for that is a
+ * refutation or `unavailable` from the attempt itself — not a flag that skips
+ * the check and calls the result verified.
+ */
+/**
+ * Runs the ladder against a shadow copy of the bound project. Stops at the
+ * first refutation, so a proposal refuted locally never reaches the warehouse.
+ *
+ * The verdict carries the proposal hash and project revision it was earned
+ * against: a verdict must not survive onto edited content or a moved project.
+ */
+export async function verifyProposal(proposal, binding, options = {}) {
+    const run = options.run ?? runWren;
+    const bound = { proposalHash: proposal.hash, projectRevision: proposal.projectRevision };
+    const stepsRun = [];
+    // Steps 1-2 need no project at all, so they run before paying for a copy.
+    for (const operation of proposal.operations) {
+        const grammar = checkGrammar(operation);
+        if (grammar !== undefined) {
+            return { status: "refuted", ...bound, stepsRun: ["sink", "grammar"], refutation: { operationId: operation.id, step: "grammar", reason: `draft ${grammar}` } };
+        }
+    }
+    stepsRun.push("sink", "grammar");
+    let shadow;
+    try {
+        shadow = await mkdtemp(path.join(tmpdir(), "wren-enrich-verify-"));
+        const project = path.join(shadow, "project");
+        // `.env` comes along: the ladder's later steps resolve the project's own
+        // connection the way any other wren invocation in that directory would.
+        await cp(binding.path, project, { recursive: true });
+        for (const operation of proposal.operations) {
+            const sinkPath = path.join(project, operation.sink);
+            // `canonicalizeProposal` already constrained every sink to a fixed shape,
+            // so this cannot escape; assert it anyway, because a path that escapes a
+            // temp directory is not a failure worth discovering later.
+            if (!path.resolve(sinkPath).startsWith(path.resolve(project) + path.sep)) {
+                return { status: "refuted", ...bound, stepsRun, refutation: { operationId: operation.id, step: "sink", reason: `sink "${operation.sink}" resolves outside the project` } };
+            }
+            // The lexical check above never touches the filesystem, so it passes for a
+            // path whose components are symlinks. `cp` does not dereference them, so a
+            // symlink in the bound project is copied AS a symlink and a later write
+            // would follow it out of the shadow — defeating the guarantee this module
+            // states. Refuse rather than follow.
+            const escaping = await symlinkComponent(project, operation.sink);
+            if (escaping !== undefined) {
+                return { status: "refuted", ...bound, stepsRun, refutation: { operationId: operation.id, step: "sink", reason: `sink "${operation.sink}" passes through a symlink ("${escaping}"), which a write would follow out of the project` } };
+            }
+            await mkdir(path.dirname(sinkPath), { recursive: true });
+            await writeFile(sinkPath, operation.draft.endsWith("\n") ? operation.draft : `${operation.draft}\n`, "utf-8");
+        }
+        const validate = await run(["context", "validate"], project);
+        stepsRun.push("validate");
+        if (validate.error !== null) {
+            if (validate.error.code === "ENOENT")
+                return { status: "unavailable", ...bound, reason: "the wren CLI is not on PATH" };
+            return { status: "refuted", ...bound, stepsRun, refutation: { operationId: proposal.operations[0]?.id ?? "", step: "validate", reason: firstMeaningfulLine(validate.stderr, validate.stdout) } };
+        }
+        const build = await run(["context", "build"], project);
+        stepsRun.push("build");
+        if (build.error !== null) {
+            return { status: "refuted", ...bound, stepsRun, refutation: { operationId: proposal.operations[0]?.id ?? "", step: "build", reason: firstMeaningfulLine(build.stderr, build.stdout) } };
+        }
+        for (const operation of proposal.operations) {
+            const probe = probeFor(operation);
+            if (probe === undefined)
+                continue; // nothing queryable (e.g. a knowledge append)
+            if (probe.kind === "relation") {
+                const plan = await run(["dry-plan", "--sql", probe.sql], project);
+                if (!stepsRun.includes("dry_plan"))
+                    stepsRun.push("dry_plan");
+                if (plan.error !== null) {
+                    return { status: "refuted", ...bound, stepsRun, refutation: { operationId: operation.id, step: "dry_plan", reason: firstMeaningfulLine(plan.stderr, plan.stdout) } };
+                }
+                continue;
+            }
+            // Cube: generate its query, then have the source parse it. Both steps are
+            // needed — generation alone accepts an invented column.
+            const generated = await run(["cube", "query", "--cube", probe.cube, "--measures", probe.measures.join(","), "--sql-only"], project);
+            if (!stepsRun.includes("dry_plan"))
+                stepsRun.push("dry_plan");
+            if (generated.error !== null) {
+                return { status: "refuted", ...bound, stepsRun, refutation: { operationId: operation.id, step: "dry_plan", reason: firstMeaningfulLine(generated.stderr, generated.stdout) } };
+            }
+            const sql = generated.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).pop();
+            if (sql === undefined) {
+                return { status: "unavailable", ...bound, reason: `could not generate a query for cube "${probe.cube}"` };
+            }
+            // Unlike the relation probe, this one reaches the data source: nothing
+            // local resolves a cube's expressions, so the alternative is not checking
+            // cubes at all. `dry-run` parses and validates without returning rows.
+            const dry = await run(["dry-run", "--sql", sql], project);
+            if (!stepsRun.includes("dry_run"))
+                stepsRun.push("dry_run");
+            if (dry.error !== null) {
+                return { status: "refuted", ...bound, stepsRun, refutation: { operationId: operation.id, step: "dry_run", reason: firstMeaningfulLine(dry.stderr, dry.stdout) } };
+            }
+        }
+        return { status: "verified", ...bound, stepsRun };
+    }
+    catch (error) {
+        // An unrunnable ladder is reported as such, never as a pass.
+        return { status: "unavailable", ...bound, reason: error.message };
+    }
+    finally {
+        if (shadow !== undefined)
+            await rm(shadow, { recursive: true, force: true }).catch(() => undefined);
+    }
+}

package/dist-server/server/enrichment.d.ts

@@ -0,0 +1,232 @@
+export type EnrichmentMode = "grill" | "autopilot";
+export type EnrichmentRisk = "low" | "high" | "conflict" | "ambiguous";
+export type EnrichmentDecision = "accept" | "edit" | "skip";
+export type EnrichmentRunStatus = "drafting" | "awaiting_decision" | "awaiting_approval" | "ready" | "completed" | "cancelled" | "reconcile_required" | "failed";
+/**
+ * Deliberately has no kind for "append a description to a model" (a change
+ * that targets the same `models/<name>/metadata.yml` sink as `mdl_metric`
+ * and `calculated_column`, but is neither). Adding one is not a host-only
+ * change: `apply_enrichment` (the warble component that applies an approved
+ * operation) already has to know a distinct per-`changeKind` merge shape for
+ * every kind that shares that sink, and a description append would be a
+ * third, different shape into the same file. That component's guardrails
+ * are locked and out of scope here, so until it grows the case, a
+ * model-description append has no valid `changeKind` and is refused by
+ * `canonicalizeProposal` like any other invalid draft — not silently
+ * reclassified as `mdl_metric`/`calculated_column`, which would misroute it.
+ */
+export type EnrichmentChangeKind = "knowledge_append" | "new_cube" | "new_view" | "new_relationship" | "mdl_metric" | "calculated_column" | "conflict" | "ambiguous";
+export type EnrichmentOperationState = "awaiting_decision" | "awaiting_approval" | "ready" | "ready_to_reapply" | "applying" | "applied" | "skipped" | "reconcile_required";
+/**
+ * Model-authored confidence is display-only. It never participates in risk,
+ * approval, or Auto-pilot eligibility. Numbers remain accepted internally so
+ * existing ledgers and callers can be read during the transition to labels.
+ */
+export type EnrichmentConfidence = string | number;
+/** Safe, sink-scoped proposal metadata. Never carry source material or SDK ids. */
+export interface EnrichmentOperation {
+    readonly id: string;
+    readonly sink: string;
+    readonly risk: EnrichmentRisk;
+    readonly summary: string;
+    readonly confidence: EnrichmentConfidence;
+    readonly changeKind: EnrichmentChangeKind;
+    readonly draft: string;
+}
+export interface EnrichmentProposal {
+    readonly id: string;
+    readonly hash: string;
+    readonly projectRevision: string;
+    readonly operations: readonly EnrichmentOperation[];
+}
+/**
+ * The host's view of the currently bound project. Paths alone are not an
+ * authority: a symlink can be retargeted and the same spelling can name a
+ * different directory. `identity` is deliberately a portable textual form of
+ * the platform's device/inode pair, while `path` is the canonical realpath.
+ */
+export interface EnrichmentBinding {
+    readonly path: string;
+    readonly identity: string;
+    readonly generation: number;
+    readonly revision: string;
+}
+export type UnversionedEnrichmentBinding = Omit<EnrichmentBinding, "generation">;
+/**
+ * The subset of a binding that identifies *which directory* is bound,
+ * independent of whether it has ever been built. Binding a project (Setup's
+ * connect step, adopt, the context step's temporary healthcheck bind) is a
+ * foundation operation that must succeed regardless of build state, so it
+ * may only ever produce this — never a revision.
+ */
+export type ProjectIdentity = Omit<UnversionedEnrichmentBinding, "revision">;
+/** Untrusted runtime draft: host ignores its ids, hash, revision and risk. */
+export interface EnrichmentDraftOperation {
+    readonly sink: string;
+    readonly changeKind: EnrichmentChangeKind;
+    readonly summary: string;
+    readonly draft: string;
+    readonly confidence?: unknown;
+    readonly id?: string;
+    readonly risk?: EnrichmentRisk;
+}
+export interface EnrichmentDraft {
+    readonly operations: readonly EnrichmentDraftOperation[];
+    readonly id?: string;
+    readonly hash?: string;
+    readonly projectRevision?: string;
+}
+/**
+ * A runner's own live answer to "can you serve `draft()` right now, and if
+ * not, why not". `reason` is a short, stable, machine-readable code (never
+ * free-form prose): it must already be safe to hand to a browser as-is, so
+ * it must never carry a runner/dispatcher path, an SDK session id, or any
+ * provider identity beyond what the caller's own runtime configuration
+ * already chose. The host route (`server/app.ts`) only forwards whatever
+ * `readiness()` returns; it never re-derives it from the runtime config
+ * itself, so a runner that grows a new refusal reason surfaces it here
+ * without the route needing to change.
+ */
+export interface EnrichmentRunnerReadiness {
+    readonly available: boolean;
+    readonly reason?: string;
+}
+export interface EnrichmentRunner {
+    /**
+     * A runner only drafts a typed proposal.  It must not mutate a project: the
+     * host validates and applies accepted operations through its completion
+     * ledger.  The production constructor deliberately does not provide one
+     * until the dispatcher exposes this callback contract.
+     */
+    draft(input: {
+        readonly projectPath: string;
+        readonly mode: EnrichmentMode;
+        readonly projectRevision: string;
+    }): Promise<unknown>;
+    /**
+     * Optional live readiness check, independent of `draft()`: it must return
+     * without dispatching, without a live model turn, and without any other
+     * cost or side effect -- a pure read of whatever the runner already
+     * consults to decide whether to refuse (e.g. the current `AuthChoice`).
+     * Omitted only by test doubles that don't model refusal; such a runner is
+     * treated as always available, matching this capability's behavior before
+     * `readiness()` existed.
+     */
+    readiness?(): EnrichmentRunnerReadiness;
+}
+/** Trusted deterministic apply seam owned and invoked by the host. */
+export interface EnrichmentApplyRunner {
+    apply(input: {
+        readonly projectPath: string;
+        readonly projectRevision: string;
+        readonly proposalHash: string;
+        readonly operation: EnrichmentOperation;
+        readonly idempotencyKey: string;
+        readonly fence: number;
+    }): Promise<{
+        readonly validationDigest: string;
+        readonly buildDigest: string;
+    }>;
+    reconcile(input: {
+        readonly idempotencyKey: string;
+        readonly fence: number;
+    }): Promise<{
+        readonly state: "applied" | "not_applied" | "still_unknown";
+        readonly validationDigest?: string;
+        readonly buildDigest?: string;
+    }>;
+}
+/** The host never sends proposal text to an approval provider. */
+export interface EnrichmentApprovalRequest {
+    readonly runId: string;
+    readonly binding: EnrichmentBinding;
+    readonly proposalHash: string;
+    readonly operation: {
+        readonly id: string;
+        readonly sink: string;
+        readonly risk: EnrichmentRisk;
+        readonly changeKind: EnrichmentChangeKind;
+        readonly hash: string;
+    };
+}
+/** A trusted host callback returns an opaque, short-lived authorization record. */
+export interface EnrichmentApprovalAttestation {
+    readonly evidenceRef: string;
+    readonly nonce: string;
+    readonly expiresAt: string;
+    readonly binding: EnrichmentBinding;
+    readonly proposalHash: string;
+    readonly operationHash: string;
+}
+export interface EnrichmentApprovalProvider {
+    attest(input: EnrichmentApprovalRequest): Promise<EnrichmentApprovalAttestation>;
+}
+export declare class EnrichmentContractError extends Error {
+}
+/**
+ * Identifies a project directory without requiring it to be built. This is
+ * the only resolution `bindProject` may use: binding must succeed for a
+ * freshly connected, not-yet-compiled project, so it can never read or
+ * require `target/mdl.json`.
+ */
+export declare function resolveProjectIdentity(projectPath: string): ProjectIdentity;
+/**
+ * Identifies a project directory *and* proves it is built. Only enrichment
+ * call sites may use this: they need a concrete revision to lock a run
+ * against or to fence an in-flight operation, and it is legitimate for them
+ * to refuse (via `EnrichmentContractError`) when the project isn't built.
+ */
+export declare function resolveEnrichmentBinding(projectPath: string): UnversionedEnrichmentBinding;
+export declare function sameEnrichmentBinding(left: EnrichmentBinding, right: EnrichmentBinding): boolean;
+export declare function computeBoundProjectRevision(projectPath: string): string;
+/**
+ * Converts untrusted model confidence into bounded UI text without making it
+ * an operation-validity gate. Unsafe, missing, or structured values become a
+ * neutral label instead of costing an otherwise valid proposal.
+ */
+export declare function normalizeEnrichmentConfidence(value: unknown): string;
+export declare function hashEnrichmentOperation(operation: Pick<EnrichmentOperation, "id" | "sink" | "risk" | "summary" | "draft" | "changeKind">): string;
+export declare function canonicalizeProposal(draft: unknown, revision: string): EnrichmentProposal;
+export declare function requiresApproval(mode: EnrichmentMode, risk: EnrichmentRisk): boolean;
+/**
+ * The host-mediated MCP tool a native `context_enrichment` session uses to
+ * hand a drafted proposal to the host. The agent never writes into the bound
+ * project directly: this tool only carries the proposal *document* through
+ * to the same canonicalize -> shadow-verify -> finalize pipeline `POST
+ * /api/context/enrichment/start` already uses (see `server/app.ts`'s
+ * `settleEnrichmentDraft`). The schema below is deliberately permissive --
+ * `canonicalizeProposal` above is the single source of truth for shape and
+ * content validation, so this schema must not duplicate or drift from it.
+ */
+export declare const NATIVE_ENRICHMENT_SUBMIT_MCP_TOOL_NAME = "submit_context_proposal";
+export declare const NATIVE_ENRICHMENT_SUBMIT_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["operations"];
+    readonly properties: {
+        readonly operations: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["sink", "changeKind", "summary", "draft"];
+                readonly properties: {
+                    readonly sink: {
+                        readonly type: "string";
+                    };
+                    readonly changeKind: {
+                        readonly enum: readonly ["knowledge_append", "new_cube", "new_view", "new_relationship", "mdl_metric", "calculated_column", "conflict", "ambiguous"];
+                    };
+                    readonly summary: {
+                        readonly type: "string";
+                    };
+                    readonly draft: {
+                        readonly type: "string";
+                    };
+                    readonly confidence: {};
+                };
+            };
+        };
+    };
+};