@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns.js

@@ -0,0 +1,217 @@
+// SPDX-License-Identifier: FSL-1.1-MIT OR MIT
+/**
+ * Space-table column definitions.
+ *
+ * A table is a small database, not a CSV dump: every column has a type and a
+ * display format. Agents create the definition; row writes are validated
+ * against it.
+ */
+import { z } from "zod";
+const COLUMN_ID = /^[a-z][a-z0-9_]*$/;
+const columnBaseSchema = z.object({
+    description: z.string().max(1024).optional(),
+    /**
+     * Where the cell is edited. Omit to use the type default:
+     * single-line text and booleans are in-field; everything else is a popout.
+     */
+    edit: z.enum(["inline", "popout"]).optional(),
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(COLUMN_ID, "column id must be a lowercase slug (a-z, 0-9, _)"),
+    name: z.string().min(1).max(128),
+    required: z.boolean().optional(),
+});
+export const numberStyleSchema = z.enum([
+    "integer",
+    "decimal",
+    "percent",
+    "currency",
+]);
+export const numberFormatSchema = z
+    .object({
+    currency: z
+        .string()
+        .regex(/^[A-Z]{3}$/, "currency must be an ISO 4217 code")
+        .optional(),
+    fractionDigits: z.number().int().min(0).max(8).optional(),
+    grouping: z.boolean().optional(),
+    style: numberStyleSchema,
+})
+    .superRefine((val, ctx) => {
+    if (val.style === "currency" && !val.currency) {
+        ctx.addIssue({
+            code: "custom",
+            message: "currency style needs an ISO 4217 code",
+            path: ["currency"],
+        });
+    }
+    if (val.style !== "currency" && val.currency) {
+        ctx.addIssue({
+            code: "custom",
+            message: "currency is only valid on currency columns",
+            path: ["currency"],
+        });
+    }
+});
+export const dateKindSchema = z.enum(["date", "datetime", "time"]);
+export const dateStyleSchema = z.enum(["short", "medium", "long", "iso"]);
+/** `hours` is clock time with no minutes — `14` or `14:30` both store as `14:00`. */
+export const timePrecisionSchema = z.enum(["hours", "minutes", "seconds"]);
+export const dateFormatSchema = z.object({
+    dateStyle: dateStyleSchema.optional(),
+    kind: dateKindSchema,
+    timePrecision: timePrecisionSchema.optional(),
+});
+export const durationUnitSchema = z.enum([
+    "milliseconds",
+    "seconds",
+    "minutes",
+    "hours",
+    "days",
+]);
+export const durationDisplaySchema = z.enum([
+    "hms",
+    "hours",
+    "minutes",
+    "decimal-hours",
+    "iso",
+]);
+export const durationFormatSchema = z.object({
+    display: durationDisplaySchema,
+    /** Unit a writer typically types; stored value is always milliseconds. */
+    inputUnit: durationUnitSchema,
+});
+export const selectOptionSchema = z.object({
+    id: z.string().min(1).max(64),
+    label: z.string().min(1).max(128),
+});
+export const selectFormatSchema = z.object({
+    /** Values outside `options` are kept as-is instead of rejected. */
+    allowCustom: z.boolean(),
+    multiple: z.boolean().optional(),
+    options: z.array(selectOptionSchema).max(200),
+});
+export const textStyleSchema = z.enum(["single", "multiline", "markdown"]);
+export const textFormatSchema = z.object({
+    /** `single` is one line; `multiline` is plain wrapping text; `markdown` is inline marks. */
+    style: textStyleSchema.default("single"),
+});
+export const tableColumnSchema = z.discriminatedUnion("type", [
+    columnBaseSchema.extend({
+        format: textFormatSchema.optional(),
+        type: z.literal("text"),
+    }),
+    columnBaseSchema.extend({
+        format: numberFormatSchema,
+        type: z.literal("number"),
+    }),
+    columnBaseSchema.extend({
+        format: dateFormatSchema,
+        type: z.literal("date"),
+    }),
+    columnBaseSchema.extend({
+        format: durationFormatSchema,
+        type: z.literal("duration"),
+    }),
+    columnBaseSchema.extend({
+        format: selectFormatSchema,
+        type: z.literal("select"),
+    }),
+    columnBaseSchema.extend({ type: z.literal("boolean") }),
+]);
+export function textColumnStyle(column) {
+    return column.type === "text" ? (column.format?.style ?? "single") : "single";
+}
+/** Where this cell is edited. Explicit `edit` wins; otherwise type defaults. */
+export function columnEdit(column) {
+    if (column.edit) {
+        return column.edit;
+    }
+    if (column.type === "boolean") {
+        return "inline";
+    }
+    if (column.type === "text" && textColumnStyle(column) === "single") {
+        return "inline";
+    }
+    return "popout";
+}
+export const tableColumnsSchema = z
+    .array(tableColumnSchema)
+    .min(1)
+    .max(64)
+    .superRefine((columns, ctx) => {
+    const seen = new Set();
+    for (let i = 0; i < columns.length; i++) {
+        const id = columns[i]?.id;
+        if (!id) {
+            continue;
+        }
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `duplicate column id "${id}"`,
+                path: [i, "id"],
+            });
+        }
+        seen.add(id);
+    }
+});
+/**
+ * The shape a MODEL is shown for `columns`, as opposed to the one we validate.
+ *
+ * `tableColumnsSchema` is a six-branch discriminated union that repeats the
+ * whole column base per branch. As a tool's JSON Schema that came to 14.7 KB —
+ * on its own 5% of a copilot prompt, resent on every model call of every run,
+ * whether or not a table is in play. The union earns that as a *contract*; it
+ * does not earn it as a *hint*.
+ *
+ * So the wire shape is one flat object with every format key optional, and the
+ * tool re-parses the result with `tableColumnsSchema` before doing anything.
+ * Validation is unchanged and the error the model gets back is the strict
+ * schema's own; only the advertisement shrinks. Per-type rules live in the
+ * tool description, which the model reads anyway.
+ */
+export const tableColumnWireSchema = z.object({
+    description: z.string().optional(),
+    edit: z.enum(["inline", "popout"]).optional(),
+    format: z
+        .object({
+        allowCustom: z.boolean().optional(),
+        currency: z.string().optional(),
+        dateStyle: z.enum(["short", "medium", "long", "iso"]).optional(),
+        display: durationDisplaySchema.optional(),
+        fractionDigits: z.number().int().optional(),
+        grouping: z.boolean().optional(),
+        inputUnit: durationUnitSchema.optional(),
+        kind: dateKindSchema.optional(),
+        multiple: z.boolean().optional(),
+        options: z.array(selectOptionSchema).optional(),
+        // `style` spans text and number columns; which values are legal follows
+        // from `type`, and the strict schema is what decides.
+        style: z
+            .enum([
+            "single",
+            "multiline",
+            "markdown",
+            "integer",
+            "decimal",
+            "percent",
+            "currency",
+        ])
+            .optional(),
+        timePrecision: timePrecisionSchema.optional(),
+    })
+        .optional(),
+    id: z.string(),
+    name: z.string(),
+    required: z.boolean().optional(),
+    type: z.enum(["text", "number", "date", "duration", "select", "boolean"]),
+});
+export const tableColumnsWireSchema = z.array(tableColumnWireSchema);
+export const DATA_TABLE_ARTIFACT_TYPE = "database";
+export const DATA_TABLE_MIME_TYPE = "application/vnd.engenty.database+json";
+export const dataTableHandleSchema = z.object({
+    table_id: z.string().uuid(),
+});

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/index.d.ts

@@ -0,0 +1,3 @@
+export { type ColumnEdit, columnEdit, DATA_TABLE_ARTIFACT_TYPE, DATA_TABLE_MIME_TYPE, type DataTableHandle, type DateFormat, type DateKind, type DateStyle, type DurationDisplay, type DurationFormat, type DurationUnit, dataTableHandleSchema, dateFormatSchema, durationFormatSchema, type NumberFormat, type NumberStyle, numberFormatSchema, type SelectFormat, type SelectOption, selectFormatSchema, type TableColumn, type TableColumnWire, type TextFormat, type TextStyle, type TimePrecision, tableColumnSchema, tableColumnsSchema, tableColumnsWireSchema, tableColumnWireSchema, textColumnStyle, textFormatSchema, textStyleSchema, } from "./columns.js";
+export { formatDateCell, formatDurationCell, formatNumberCell, formatTableCell, } from "./columns-format.js";
+export { coerceColumnValue, coerceRowValues, mergeRowValues, parseTableColumns, TableColumnValueError, } from "./columns-value.js";

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/index.js

@@ -0,0 +1,3 @@
+export { columnEdit, DATA_TABLE_ARTIFACT_TYPE, DATA_TABLE_MIME_TYPE, dataTableHandleSchema, dateFormatSchema, durationFormatSchema, numberFormatSchema, selectFormatSchema, tableColumnSchema, tableColumnsSchema, tableColumnsWireSchema, tableColumnWireSchema, textColumnStyle, textFormatSchema, textStyleSchema, } from "./columns.js";
+export { formatDateCell, formatDurationCell, formatNumberCell, formatTableCell, } from "./columns-format.js";
+export { coerceColumnValue, coerceRowValues, mergeRowValues, parseTableColumns, TableColumnValueError, } from "./columns-value.js";

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-lexical.d.ts

@@ -0,0 +1,14 @@
+export type CatalogSearchEntry = Record<string, unknown>;
+export type CatalogFieldWeights = ReadonlyArray<readonly [string, number]>;
+export declare const CATALOG_FIELD_WEIGHTS: CatalogFieldWeights;
+export declare function tokenizeCatalogText(value: string): string[];
+export declare function stringifyCatalogSearchValue(value: unknown): string;
+/**
+ * Weighted "key: value" text for an entry — the canonical input for
+ * embedding an entry when a consumer layers semantic search on top.
+ */
+export declare function buildCatalogSearchText(entry: CatalogSearchEntry, weights?: CatalogFieldWeights): string;
+/** BM25-like weighted-field lexical score; 0 when the query has no overlap. */
+export declare function scoreCatalogEntry(entry: CatalogSearchEntry, query?: string, weights?: CatalogFieldWeights): number;
+/** Sort entries by precomputed lexical score, dropping zero-score entries. */
+export declare function rankLexically<T extends CatalogSearchEntry>(entries: T[], lexicalScores: number[]): T[];

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-lexical.js

@@ -0,0 +1,166 @@
+// Shared lexical scoring for API-catalog-shaped entries.
+//
+// Extracted from apps/core's api-catalog search so both apps/core (the
+// `core_api_catalog_search` gateway method, lexical-only) and apps/ai
+// (the agent-facing catalog provider, which layers semantic reranking on
+// top) score entries the same way. Entries are plain records; callers
+// pick which fields matter via a weight list.
+// Default weights match the historical apps/core catalog ranking (entries
+// produced by buildApiCatalog: HTTP routes + tool operations).
+export const CATALOG_FIELD_WEIGHTS = [
+    ["id", 8],
+    ["toolId", 10],
+    ["moduleId", 7],
+    ["pluginId", 6],
+    ["title", 6],
+    ["description", 4],
+    ["tags", 3],
+    ["path", 3],
+    ["inputSchema", 2],
+    ["outputSchema", 2],
+    ["request", 1],
+    ["response", 1],
+];
+function normalizeText(value) {
+    return value
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase();
+}
+export function tokenizeCatalogText(value) {
+    return normalizeText(value)
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1);
+}
+export function stringifyCatalogSearchValue(value) {
+    if (value == null) {
+        return "";
+    }
+    if (Array.isArray(value)) {
+        return value.map(stringifyCatalogSearchValue).filter(Boolean).join(" ");
+    }
+    if (typeof value === "object") {
+        return Object.values(value)
+            .map(stringifyCatalogSearchValue)
+            .filter(Boolean)
+            .join(" ");
+    }
+    return String(value);
+}
+function buildSearchDocument(entry, weights) {
+    const fields = weights
+        .map(([key, weight]) => ({
+        text: stringifyCatalogSearchValue(entry[key]),
+        weight,
+    }))
+        .filter((field) => field.text.length > 0);
+    const tokens = fields.flatMap((field) => tokenizeCatalogText(field.text));
+    return { fields, tokens };
+}
+/**
+ * Weighted "key: value" text for an entry — the canonical input for
+ * embedding an entry when a consumer layers semantic search on top.
+ */
+export function buildCatalogSearchText(entry, weights = CATALOG_FIELD_WEIGHTS) {
+    return weights
+        .map(([key]) => {
+        const value = stringifyCatalogSearchValue(entry[key]);
+        return value ? `${key}: ${value}` : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function inflectionStems(token) {
+    const stems = [token];
+    if (token.length < 5) {
+        return stems;
+    }
+    if (token.endsWith("ing")) {
+        const base = token.slice(0, -3);
+        if (base.length >= 3) {
+            stems.push(base, `${base}e`);
+        }
+    }
+    else if (token.endsWith("ies") && token.length >= 6) {
+        stems.push(`${token.slice(0, -3)}y`);
+    }
+    else if (token.endsWith("es")) {
+        stems.push(token.slice(0, -2), token.slice(0, -1));
+    }
+    else if (token.endsWith("ed")) {
+        const base = token.slice(0, -2);
+        stems.push(base, `${base}e`);
+    }
+    else if (token.endsWith("s") && !token.endsWith("ss")) {
+        stems.push(token.slice(0, -1));
+    }
+    return [...new Set(stems)];
+}
+function tokenMatchStrength(queryToken, candidate) {
+    if (queryToken === candidate) {
+        return 1;
+    }
+    let best = 0;
+    for (const queryStem of inflectionStems(queryToken)) {
+        for (const candidateStem of inflectionStems(candidate)) {
+            if (queryStem === candidateStem) {
+                best = Math.max(best, queryStem === queryToken && candidateStem === candidate ? 1 : 0.75);
+                continue;
+            }
+            if (queryStem.length >= 2 && candidateStem.startsWith(queryStem)) {
+                best = Math.max(best, 0.55 * (queryStem.length / candidateStem.length));
+            }
+            if (candidateStem.length >= 4 && queryStem.startsWith(candidateStem)) {
+                best = Math.max(best, 0.4 * (candidateStem.length / queryStem.length));
+            }
+        }
+    }
+    return best;
+}
+function weightedTokenFrequency(tokens, queryToken) {
+    return tokens.reduce((sum, token) => sum + tokenMatchStrength(queryToken, token), 0);
+}
+/** BM25-like weighted-field lexical score; 0 when the query has no overlap. */
+export function scoreCatalogEntry(entry, query, weights = CATALOG_FIELD_WEIGHTS) {
+    if (!query?.trim()) {
+        return 0;
+    }
+    const queryTokens = tokenizeCatalogText(query);
+    if (queryTokens.length === 0) {
+        return 0;
+    }
+    const document = buildSearchDocument(entry, weights);
+    if (document.tokens.length === 0) {
+        return 0;
+    }
+    return queryTokens.reduce((score, token) => {
+        const termFrequency = weightedTokenFrequency(document.tokens, token);
+        if (termFrequency === 0) {
+            return score;
+        }
+        const fieldScore = document.fields.reduce((sum, field) => {
+            const fieldTokens = tokenizeCatalogText(field.text);
+            const fieldFrequency = weightedTokenFrequency(fieldTokens, token);
+            if (fieldFrequency === 0) {
+                return sum;
+            }
+            const bm25Like = (fieldFrequency * 2.2) /
+                (fieldFrequency + 1.2 + fieldTokens.length / 16);
+            return sum + field.weight * bm25Like;
+        }, 0);
+        return score + fieldScore;
+    }, 0);
+}
+/** Sort entries by precomputed lexical score, dropping zero-score entries. */
+export function rankLexically(entries, lexicalScores) {
+    return entries
+        .map((entry, index) => ({
+        entry,
+        score: lexicalScores[index] ?? 0,
+    }))
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .map((item) => item.entry);
+}

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-rank.d.ts

@@ -0,0 +1,33 @@
+import { type CatalogFieldWeights, type CatalogSearchEntry } from "./catalog-lexical.js";
+export type CatalogRankStrategy = "hybrid" | "lexical" | "semantic";
+/** Name/description records (space modules, skills, connections, agents). */
+export declare const RECORD_CATALOG_FIELD_WEIGHTS: CatalogFieldWeights;
+/**
+ * Rank name/description records by lexical BM25 (prefix + inflection).
+ * Empty query keeps input order; zero-score rows drop out.
+ */
+export declare function rankRecordsLexically<T>(items: readonly T[], query: string, toRecord: (item: T) => CatalogSearchEntry, weights?: CatalogFieldWeights): T[];
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function blendCatalogScores(params: {
+    lexical: number;
+    maxLexical: number;
+    semantic: number;
+    strategy: CatalogRankStrategy;
+}): number;
+export interface ScoredCatalogItem<T> {
+    entry: T;
+    lexical: number;
+    score: number;
+    semantic: number;
+}
+/**
+ * Sort catalog rows by blended score. Lexical hits always survive; semantic
+ * hits need to clear `minSemantic` (default 0 means any cosine > 0).
+ */
+export declare function rankScoredCatalog<T>(items: ReadonlyArray<{
+    entry: T;
+    lexical: number;
+    semantic: number;
+}>, strategy: CatalogRankStrategy, options?: {
+    minSemantic?: number;
+}): ScoredCatalogItem<T>[];

package/node_modules/@engenty-wizards/shared/dist/engenty/search-index/catalog-rank.js

@@ -0,0 +1,99 @@
+// Shared hybrid ranking for catalog-shaped records.
+//
+// Lexical BM25 lives in catalog-lexical.ts. This module blends those scores
+// with cosine similarity when a consumer (apps/ai today) supplies embeddings.
+// UI pickers can call rankScoredCatalog with semantic=0 for lexical-only.
+import { scoreCatalogEntry, } from "./catalog-lexical.js";
+/** Name/description records (space modules, skills, connections, agents). */
+export const RECORD_CATALOG_FIELD_WEIGHTS = [
+    ["name", 10],
+    ["id", 8],
+    ["title", 6],
+    ["summary", 6],
+    ["description", 6],
+    ["category", 5],
+    ["modules", 4],
+    ["connectorId", 4],
+    ["role", 3],
+    ["tags", 3],
+    ["source", 2],
+];
+/**
+ * Rank name/description records by lexical BM25 (prefix + inflection).
+ * Empty query keeps input order; zero-score rows drop out.
+ */
+export function rankRecordsLexically(items, query, toRecord, weights = RECORD_CATALOG_FIELD_WEIGHTS) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return [...items];
+    }
+    return items
+        .map((item) => ({
+        item,
+        score: scoreCatalogEntry(toRecord(item), trimmed, weights),
+    }))
+        .filter((row) => row.score > 0)
+        .sort((left, right) => right.score - left.score)
+        .map((row) => row.item);
+}
+export function cosineSimilarity(a, b) {
+    const length = Math.min(a.length, b.length);
+    if (length === 0) {
+        return 0;
+    }
+    let dot = 0;
+    let left = 0;
+    let right = 0;
+    for (let index = 0; index < length; index += 1) {
+        const aValue = a[index] ?? 0;
+        const bValue = b[index] ?? 0;
+        dot += aValue * bValue;
+        left += aValue * aValue;
+        right += bValue * bValue;
+    }
+    const denominator = Math.sqrt(left) * Math.sqrt(right);
+    if (denominator === 0) {
+        return 0;
+    }
+    return dot / denominator;
+}
+export function blendCatalogScores(params) {
+    if (params.strategy === "lexical") {
+        return params.lexical;
+    }
+    if (params.strategy === "semantic") {
+        return params.semantic;
+    }
+    const normalizedLexical = params.maxLexical > 0 ? params.lexical / params.maxLexical : 0;
+    return params.semantic * 0.65 + normalizedLexical * 0.35;
+}
+/**
+ * Sort catalog rows by blended score. Lexical hits always survive; semantic
+ * hits need to clear `minSemantic` (default 0 means any cosine > 0).
+ */
+export function rankScoredCatalog(items, strategy, options = {}) {
+    const minSemantic = options.minSemantic ?? 0;
+    const maxLexical = Math.max(...items.map((item) => item.lexical), 0);
+    return items
+        .map((item) => ({
+        entry: item.entry,
+        lexical: item.lexical,
+        score: blendCatalogScores({
+            lexical: item.lexical,
+            maxLexical,
+            semantic: item.semantic,
+            strategy,
+        }),
+        semantic: item.semantic,
+    }))
+        .filter((item) => {
+        if (strategy === "lexical") {
+            return item.lexical > 0;
+        }
+        if (strategy === "semantic") {
+            return item.semantic > minSemantic;
+        }
+        return item.lexical > 0 || item.semantic > minSemantic;
+    })
+        .sort((a, b) => b.score - a.score);
+}

package/node_modules/@engenty-wizards/shared/dist/feature-flags.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The feature flags of the core: the parts that ship in the code but are not on for everyone
+ * yet (`release`), and the parts a plan includes (`plan`). This file is the list – add a flag
+ * here, branch on it with `useFeature("name")` in the studio or `feature("name")` in the
+ * runtime, and delete it with its branches once its default became `true`.
+ *
+ * How a flag gets its value (defaults here → `FEATURES` env → the Manage-App → the `.features`
+ * file) lives in features.ts. A plugin's flags are declared in its manifest under `features`
+ * and are known as `<plugin id>.<name>`; they do not belong here. No public page lists these.
+ */
+export interface FeatureDeclaration {
+    kind: "release" | "plan";
+    /** What counts until a layer says otherwise. */
+    default: boolean;
+    /** A few words for the lists: `wizards features`, the admin's switches. */
+    label: string;
+    hint?: string;
+}
+/**
+ * One entry per flag. `kind: "release"`: on or off for everyone by default, turned on for a
+ * team or a machine before the default flips. `kind: "plan"`: on until a plan says `false`.
+ */
+export declare const FEATURES: {
+    readonly account: {
+        readonly kind: "release";
+        readonly default: true;
+        readonly label: "Account in a local install";
+        readonly hint: "Linking, Settings → Account, the offer to sign in.";
+    };
+    readonly unsetConnectors: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Connectors without an OAuth client";
+        readonly hint: "Built-in connectors are shown although their client is not set up.";
+    };
+    readonly site: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Link to the website in the setup";
+        readonly hint: "The local install's setup links the product's site.";
+    };
+    readonly teamPlans: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Team plans";
+        readonly hint: "The team page in the cloud studio, and plans that carry this switch on the account pages.";
+    };
+    readonly brandSections: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Sections in Info & brand";
+        readonly hint: "Sections of logos and of colours, gradients and patterns among them.";
+    };
+    readonly brandRules: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Rules in Info & brand";
+        readonly hint: "Rules for how the logos, the colours and the type may be used.";
+    };
+    readonly typography: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Typography in Info & brand";
+        readonly hint: "The brand's fonts, their licences and a type scale.";
+    };
+    readonly goose: {
+        readonly kind: "release";
+        readonly default: false;
+        readonly label: "Goose";
+        readonly hint: "The studio's assistant: its chat at the foot of the page and in the sidebar.";
+    };
+    readonly ownKeys: {
+        readonly kind: "plan";
+        readonly default: true;
+        readonly label: "Own API keys";
+        readonly hint: "The team puts its providers' keys into the cloud studio instead of running on credits.";
+    };
+};