@terreno/blocks 57.10.1

package/dist/asks/headless.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingAskListSchema = exports.pendingAskListItemSchema = exports.turnResultSchema = exports.pendingAskSummarySchema = exports.turnRequestSchema = exports.askResponseWithToolCallIdSchema = exports.askSurfaceSchema = void 0;
+const zod_1 = require("zod");
+const schema_1 = require("./schema");
+const simpleCard_1 = require("./simpleCard");
+const TURN_SHAPES = "prompt, askResponse, or toolCallId with buttonId";
+exports.askSurfaceSchema = zod_1.z
+    .enum(schema_1.ASK_SURFACES)
+    .describe('Where the user answers. "compact" is a watch or another small screen: the agent asks only questions whose buttons show every option, and keeps replies to two short sentences. Defaults to "full".');
+const toolCallIdSchema = zod_1.z.string().min(1).describe("The pending ask's toolCallId.");
+/** An answer to a pending ask: the answer envelope plus the ask's `toolCallId`. */
+exports.askResponseWithToolCallIdSchema = zod_1.z.discriminatedUnion("action", [
+    schema_1.askAcceptResponseSchema.extend({ toolCallId: toolCallIdSchema }),
+    schema_1.askDeclineResponseSchema.extend({ toolCallId: toolCallIdSchema }),
+    schema_1.askCancelResponseSchema.extend({ toolCallId: toolCallIdSchema }),
+]);
+/** Puts every issue on a field, because clients show request errors next to the field they name. */
+const checkTurnRequest = (body, ctx) => {
+    const sent = ["askResponse", "buttonId", "prompt", "toolCallId"].filter((key) => body[key] !== undefined);
+    const hasButton = sent.includes("buttonId") || sent.includes("toolCallId");
+    const shapeCount = Number(sent.includes("prompt")) + Number(sent.includes("askResponse")) + Number(hasButton);
+    if (shapeCount === 0) {
+        ctx.addIssue({ code: "custom", message: `Send one of ${TURN_SHAPES}.`, path: ["prompt"] });
+        return;
+    }
+    if (shapeCount > 1) {
+        for (const key of sent) {
+            ctx.addIssue({ code: "custom", message: `Send only one of ${TURN_SHAPES}.`, path: [key] });
+        }
+        return;
+    }
+    if (hasButton && body.toolCallId === undefined) {
+        ctx.addIssue({ code: "custom", message: "Send toolCallId with buttonId.", path: ["toolCallId"] });
+    }
+    if (hasButton && body.buttonId === undefined) {
+        ctx.addIssue({ code: "custom", message: "Send buttonId with toolCallId.", path: ["buttonId"] });
+    }
+};
+/** The body of `POST /gpt/histories/:id/turn`. */
+exports.turnRequestSchema = zod_1.z
+    .object({
+    askResponse: exports.askResponseWithToolCallIdSchema
+        .optional()
+        .describe("A full answer to the pending ask, as a client that renders the ask sends it."),
+    buttonId: zod_1.z
+        .string()
+        .min(1)
+        .optional()
+        .describe("The id of the simple card button the user pressed. Send it with toolCallId."),
+    prompt: zod_1.z
+        .string()
+        .min(1)
+        .optional()
+        .describe("A new message from the user. It cancels the pending ask, if there is one."),
+    surface: exports.askSurfaceSchema.optional(),
+    toolCallId: toolCallIdSchema.optional(),
+})
+    .strict()
+    .superRefine(checkTurnRequest)
+    .describe(`Send exactly one of ${TURN_SHAPES}, plus an optional surface.`);
+exports.pendingAskSummarySchema = zod_1.z
+    .object({
+    kind: zod_1.z.enum(schema_1.ASK_KINDS),
+    simple: simpleCard_1.simpleCardSchema,
+    toolCallId: zod_1.z.string().min(1),
+})
+    .strict()
+    .describe("The ask the turn paused on. Answer it with its toolCallId and the id of one of simple.buttons.");
+/** What `POST /gpt/histories/:id/turn` returns in `data` once the turn finishes. */
+exports.turnResultSchema = zod_1.z
+    .object({
+    error: zod_1.z
+        .string()
+        .optional()
+        .describe("Set when the turn failed after it started. text holds what the agent said before the error."),
+    historyId: zod_1.z.string().min(1).describe("The conversation's id."),
+    pendingAsk: exports.pendingAskSummarySchema.optional(),
+    text: zod_1.z.string().describe("The agent's reply, or an empty string when it only asked."),
+    title: zod_1.z.string().optional().describe("The conversation's title, once it has one."),
+})
+    .strict();
+exports.pendingAskListItemSchema = zod_1.z
+    .object({
+    created: zod_1.z.iso.datetime().describe("When the agent asked, as an ISO 8601 UTC timestamp."),
+    historyId: zod_1.z.string().min(1).describe("The conversation the ask belongs to."),
+    kind: zod_1.z.enum(schema_1.ASK_KINDS),
+    simple: simpleCard_1.simpleCardSchema,
+    title: zod_1.z.string().optional().describe("The conversation's title, once it has one."),
+    toolCallId: zod_1.z.string().min(1),
+})
+    .strict();
+/** What `GET /gpt/histories/pendingAsks` returns in `data`: the caller's pending asks, newest first. */
+exports.pendingAskListSchema = zod_1.z.array(exports.pendingAskListItemSchema);

package/dist/asks/jsonSchema.d.ts

@@ -0,0 +1,6 @@
+/**
+ * JSON Schema (draft-07) documents for native clients, such as a watch app generating Swift
+ * `Codable` types: the simple card and the bodies of the two headless endpoints. Keyed by the file
+ * name they are committed under in `blocks/schemas/`.
+ */
+export declare const askJsonSchemas: () => Record<string, Record<string, unknown>>;

package/dist/asks/jsonSchema.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askJsonSchemas = void 0;
+const zod_1 = require("zod");
+const headless_1 = require("./headless");
+const schema_1 = require("./schema");
+const simpleCard_1 = require("./simpleCard");
+/** Titles for nested schemas, so types generated from the documents get readable names. */
+const NESTED_TITLES = new Map([
+    [schema_1.askResponseSchema, "AskResponse"],
+    [headless_1.askResponseWithToolCallIdSchema, "AskAnswer"],
+    [headless_1.pendingAskListItemSchema, "PendingAsk"],
+    [headless_1.pendingAskSummarySchema, "PendingAskSummary"],
+    [simpleCard_1.simpleCardButtonSchema, "SimpleCardButton"],
+    [simpleCard_1.simpleCardSchema, "SimpleCard"],
+    [headless_1.turnResultSchema, "TurnResult"],
+]);
+const requestIdSchema = zod_1.z
+    .string()
+    .optional()
+    .describe("The request's id. Apps built with TerrenoApp add it to every JSON response; quote it when reporting a problem.");
+const DOCUMENTS = {
+    "pendingAsksResponse.schema.json": {
+        description: "The response body of GET /gpt/histories/pendingAsks: the caller's pending asks, newest first.",
+        schema: zod_1.z.object({ data: headless_1.pendingAskListSchema, requestId: requestIdSchema }).strict(),
+        title: "PendingAsksResponse",
+    },
+    "simpleCard.schema.json": {
+        description: "The small-screen form of an ask: short text and at most three buttons, each carrying the exact answer it sends. Button ids are unique within a card, which JSON Schema cannot express.",
+        schema: simpleCard_1.simpleCardSchema,
+        title: "SimpleCard",
+    },
+    "turnRequest.schema.json": {
+        description: "The request body of POST /gpt/histories/{id}/turn. Send exactly one of prompt, askResponse, or toolCallId with buttonId, plus an optional surface. JSON Schema cannot express that rule; the server enforces it.",
+        schema: headless_1.turnRequestSchema,
+        title: "TurnRequest",
+    },
+    "turnResponse.schema.json": {
+        description: "The response body of POST /gpt/histories/{id}/turn, sent once the turn finishes.",
+        schema: zod_1.z.object({ data: headless_1.turnResultSchema, requestId: requestIdSchema }).strict(),
+        title: "TurnResponse",
+    },
+};
+const toDocument = ({ description, schema, title }) => {
+    const { $schema, description: _schemaDescription, title: _schemaTitle, ...rest } = zod_1.z.toJSONSchema(schema, {
+        override: ({ jsonSchema, zodSchema }) => {
+            const nestedTitle = NESTED_TITLES.get(zodSchema);
+            if (nestedTitle) {
+                jsonSchema.title = nestedTitle;
+            }
+        },
+        target: "draft-7",
+    });
+    return { $schema, description, title, ...rest };
+};
+/**
+ * JSON Schema (draft-07) documents for native clients, such as a watch app generating Swift
+ * `Codable` types: the simple card and the bodies of the two headless endpoints. Keyed by the file
+ * name they are committed under in `blocks/schemas/`.
+ */
+const askJsonSchemas = () => Object.fromEntries(Object.entries(DOCUMENTS).map(([fileName, document]) => [fileName, toDocument(document)]));
+exports.askJsonSchemas = askJsonSchemas;

package/dist/asks/limits.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Hard limits for asks. The schemas, the prompt section, the docs, and the tests all read these
+ * values, so change them here only.
+ */
+export declare const ASK_LIMITS: {
+    readonly cancelReasonMaxLength: 200;
+    readonly choice: {
+        readonly optionDescriptionMaxLength: 280;
+        readonly optionIdMaxLength: 64;
+        /** Must allow exactly `optionIdMaxLength` characters. */
+        readonly optionIdPattern: RegExp;
+        readonly optionLabelMaxLength: 120;
+        readonly optionsMax: 50;
+        readonly optionsMin: 2;
+        readonly otherMaxLength: 500;
+    };
+    readonly confirm: {
+        /** Every confirm label fits a simple card button uncut. */
+        readonly labelMaxLength: 20;
+    };
+    readonly files: {
+        /** The per-file cap when the host sets no `maxFileSizeBytes`, matching `/files/upload`. */
+        readonly defaultMaxFileSizeBytes: number;
+        readonly filenameMaxLength: 255;
+        readonly maxFiles: 10;
+        readonly minFiles: 1;
+        /** Text, CSV, and JSON files reach the model cut to this many bytes, with a note. */
+        readonly textMaxBytes: 100000;
+    };
+    readonly form: {
+        readonly fieldsMax: 8;
+        readonly fieldsMin: 1;
+        readonly helperTextMaxLength: 280;
+        readonly labelMaxLength: 120;
+        /** The fewest and most digits in a `phone` value. */
+        readonly phoneDigitsMax: 15;
+        readonly phoneDigitsMin: 7;
+        /** The cap on a `textarea` value and on a `textarea` field's `maxLength`. */
+        readonly textareaMaxLength: 10000;
+        /** The cap on a `text`, `email`, `url`, or `phone` value, and on a `text` field's `maxLength`. */
+        readonly textMaxLength: 2000;
+    };
+    readonly markdown: {
+        /** The cap on `initial`, on `maxLength`, and on every answer. */
+        readonly maxLength: 20000;
+        readonly placeholderMaxLength: 120;
+    };
+    readonly pendingAsksPerHistory: 1;
+    readonly promptMaxLength: 500;
+    readonly simpleCard: {
+        readonly buttonLabelMaxLength: 20;
+        readonly buttonsMax: 3;
+        readonly textMaxLength: 140;
+        readonly titleMaxLength: 40;
+    };
+    readonly submitLabelMaxLength: 24;
+    readonly titleMaxLength: 80;
+};

package/dist/asks/limits.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASK_LIMITS = void 0;
+/**
+ * Hard limits for asks. The schemas, the prompt section, the docs, and the tests all read these
+ * values, so change them here only.
+ */
+exports.ASK_LIMITS = {
+    cancelReasonMaxLength: 200,
+    choice: {
+        optionDescriptionMaxLength: 280,
+        optionIdMaxLength: 64,
+        /** Must allow exactly `optionIdMaxLength` characters. */
+        optionIdPattern: /^[a-z0-9][a-z0-9_-]{0,63}$/,
+        optionLabelMaxLength: 120,
+        optionsMax: 50,
+        optionsMin: 2,
+        otherMaxLength: 500,
+    },
+    confirm: {
+        /** Every confirm label fits a simple card button uncut. */
+        labelMaxLength: 20,
+    },
+    files: {
+        /** The per-file cap when the host sets no `maxFileSizeBytes`, matching `/files/upload`. */
+        defaultMaxFileSizeBytes: 10 * 1024 * 1024,
+        filenameMaxLength: 255,
+        maxFiles: 10,
+        minFiles: 1,
+        /** Text, CSV, and JSON files reach the model cut to this many bytes, with a note. */
+        textMaxBytes: 100_000,
+    },
+    form: {
+        fieldsMax: 8,
+        fieldsMin: 1,
+        helperTextMaxLength: 280,
+        labelMaxLength: 120,
+        /** The fewest and most digits in a `phone` value. */
+        phoneDigitsMax: 15,
+        phoneDigitsMin: 7,
+        /** The cap on a `textarea` value and on a `textarea` field's `maxLength`. */
+        textareaMaxLength: 10_000,
+        /** The cap on a `text`, `email`, `url`, or `phone` value, and on a `text` field's `maxLength`. */
+        textMaxLength: 2000,
+    },
+    markdown: {
+        /** The cap on `initial`, on `maxLength`, and on every answer. */
+        maxLength: 20_000,
+        placeholderMaxLength: 120,
+    },
+    pendingAsksPerHistory: 1,
+    promptMaxLength: 500,
+    simpleCard: {
+        buttonLabelMaxLength: 20,
+        buttonsMax: 3,
+        textMaxLength: 140,
+        titleMaxLength: 40,
+    },
+    submitLabelMaxLength: 24,
+    titleMaxLength: 80,
+};

package/dist/asks/prompt.d.ts

@@ -0,0 +1,10 @@
+import { type AskKind, type AskSurface } from "./schema";
+/**
+ * The system prompt section that describes the enabled ask kinds and their limits. Every number
+ * comes from `ASK_LIMITS`. With `surface: "compact"`, it lists only the kinds the compact surface
+ * offers, with their narrowed limits. Returns an empty string when no kinds are offered.
+ */
+export declare const askPromptSection: ({ kinds, surface, }: {
+    kinds: readonly AskKind[];
+    surface?: AskSurface;
+}) => string;

package/dist/asks/prompt.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askPromptSection = void 0;
+const limits_1 = require("./limits");
+const schema_1 = require("./schema");
+const CHOICE_ANSWER_EXAMPLE = '- An accepted answer looks like {"action": "accept", "content": {"selected": ["<id>"]}}.';
+const CHOICE_DECLINE_RULE = "- allowDecline: optional, default true (the user sees Skip). Set it to false only when you cannot continue without an answer.";
+const CHOICE_ID_RULE = `- id: 1-${limits_1.ASK_LIMITS.choice.optionIdMaxLength} lowercase letters, digits, "_", or "-", starting with a letter or digit. Unique within the ask.`;
+const sharedRules = () => [
+    "Rules for every ask:",
+    `- prompt: required. Plain text with no markdown and no links, 1-${limits_1.ASK_LIMITS.promptMaxLength} characters.`,
+    `- title: optional, at most ${limits_1.ASK_LIMITS.titleMaxLength} characters.`,
+    "- Each ask kind below lists its other fields, including whether the user can skip it.",
+].join("\n");
+const compactSharedRules = () => [
+    sharedRules(),
+    `- The screen is small: it shows only the first ${limits_1.ASK_LIMITS.simpleCard.textMaxLength} characters of prompt and the first ${limits_1.ASK_LIMITS.simpleCard.titleMaxLength} characters of title, so keep both within those lengths.`,
+].join("\n");
+const choiceRules = () => {
+    const { choice, simpleCard } = limits_1.ASK_LIMITS;
+    return [
+        "ask_choice: the user picks one or more options from a list you provide.",
+        '- select: "one" for exactly one option, or "many" to let the user pick several.',
+        `- options: ${choice.optionsMin}-${choice.optionsMax} items, each {id, label, description?}.`,
+        CHOICE_ID_RULE,
+        `- label: at most ${choice.optionLabelMaxLength} characters. description: optional, at most ${choice.optionDescriptionMaxLength} characters.`,
+        '- default: optional list of option ids to preselect, each listed once. With "one", at most one id; with "many", at most maxSelected ids.',
+        '- minSelected, maxSelected: optional whole numbers, "many" only. The user picks from minSelected (default 1, at least 0) to maxSelected (default: every choice) choices.',
+        `- allowOther: optional, "many" only. true adds a text field where the user types an answer of their own, up to ${choice.otherMaxLength} characters. It counts as one choice. otherLabel: optional label for that field, at most ${choice.optionLabelMaxLength} characters. For one option or Other, use "many" with maxSelected 1.`,
+        `- submitLabel: optional label for the submit button, at most ${limits_1.ASK_LIMITS.submitLabelMaxLength} characters.`,
+        CHOICE_DECLINE_RULE,
+        `- Prefer select "one" with at most ${simpleCard.buttonsMax} options with labels of ${simpleCard.buttonLabelMaxLength} characters or fewer; small screens show those as buttons.`,
+        CHOICE_ANSWER_EXAMPLE,
+        '- With Other, it looks like {"action": "accept", "content": {"selected": ["<id>"], "other": "<text the user typed>"}}.',
+    ].join("\n");
+};
+const compactChoiceRules = () => {
+    const { choice, simpleCard } = limits_1.ASK_LIMITS;
+    return [
+        "ask_choice: the user picks one option by tapping its button.",
+        '- select: always "one".',
+        `- options: ${choice.optionsMin}-${simpleCard.buttonsMax} items, each {id, label, description?}.`,
+        CHOICE_ID_RULE,
+        `- label: at most ${simpleCard.buttonLabelMaxLength} characters, counting each emoji as 2 or more, and no two options share a label.`,
+        `- description: optional, at most ${choice.optionDescriptionMaxLength} characters. The buttons show only labels, so put what the user needs to decide in prompt and the labels.`,
+        "- default: optional list with at most one option id to preselect.",
+        CHOICE_DECLINE_RULE,
+        CHOICE_ANSWER_EXAMPLE,
+    ].join("\n");
+};
+/** A confirm always fits a simple card, so the full and compact surfaces share these rules. */
+const confirmRules = () => {
+    const { labelMaxLength } = limits_1.ASK_LIMITS.confirm;
+    return [
+        "ask_confirm: the user approves or denies one action you describe in prompt.",
+        `- confirmLabel, denyLabel: optional labels for the approve and deny buttons, at most ${labelMaxLength} characters each, counting each emoji as 2 or more, and different from each other. They default to "Confirm" and "Cancel". Name the action, such as "Delete 14 todos" and "Keep them".`,
+        "- destructive: optional, default false. Set it to true when the action deletes data or cannot be undone; the approve button then shows as destructive.",
+        "- allowDecline: optional, default false, because the deny button is the negative answer. Set it to true to show Skip as well.",
+        `- Before you call a tool that deletes data, sends something on the user's behalf, spends money, or cannot be undone, call ask_confirm and say in prompt exactly what will happen. Make the call only after {"confirmed": true}.`,
+        '- An accepted answer looks like {"action": "accept", "content": {"confirmed": true}}. {"confirmed": false} means the user said no, so do not take the action.',
+    ].join("\n");
+};
+const markdownRules = () => {
+    const { markdown } = limits_1.ASK_LIMITS;
+    return [
+        "ask_markdown: the user edits a markdown draft you write and sends it back.",
+        `- initial: optional, the draft in markdown, at most ${markdown.maxLength} characters. Put the whole draft here, not in prompt.`,
+        `- minLength, maxLength: optional whole numbers. The answer must have at least minLength (default 0) and at most maxLength (default ${markdown.maxLength}, the most allowed) characters. minLength must not be more than maxLength.`,
+        `- placeholder: optional hint shown while the editor is empty, at most ${markdown.placeholderMaxLength} characters.`,
+        `- submitLabel: optional label for the submit button, at most ${limits_1.ASK_LIMITS.submitLabelMaxLength} characters.`,
+        "- allowDecline: optional, default true (the user sees Skip).",
+        '- An accepted answer looks like {"action": "accept", "content": {"markdown": "<the text>", "changed": true}}. changed is false when the user sent your draft unchanged.',
+    ].join("\n");
+};
+const formRules = () => {
+    const { choice, form } = limits_1.ASK_LIMITS;
+    return [
+        "ask_form: the user fills in a few fields and submits them at once.",
+        `- fields: ${form.fieldsMin}-${form.fieldsMax} items, in display order, each {id, type, label, helperText?, required?, default?} plus the rules of its type. Fields are flat: no nesting, no conditional fields, and no password fields.`,
+        `- id: 1-${choice.optionIdMaxLength} lowercase letters, digits, "_", or "-", starting with a letter or digit. Unique within the form. It keys the field's value in the answer.`,
+        `- label: at most ${form.labelMaxLength} characters. helperText: optional, at most ${form.helperTextMaxLength} characters. required: optional, default false; true means the answer must hold a non-blank value.`,
+        `- type "text" (one line) or "textarea" (several lines): optional minLength and maxLength. maxLength is at most ${form.textMaxLength} for text and ${form.textareaMaxLength} for textarea. The value is a string.`,
+        `- type "email", "url" (http or https), or "phone" (${form.phoneDigitsMin}-${form.phoneDigitsMax} digits): the value is a string in that format.`,
+        '- type "number": optional min, max, and integer (true for whole numbers only). The value is a number.',
+        '- type "date" (YYYY-MM-DD), "time" (24-hour HH:mm), or "datetime" (ISO 8601 with Z or an offset; seconds are optional, such as "2026-10-01T09:30Z" or "2026-10-01T09:30:00+02:00"): the value is a string in that format.',
+        '- type "boolean": a checkbox. The value is true or false.',
+        `- type "select" (pick one) or "multiselect" (pick any): options, ${choice.optionsMin}-${choice.optionsMax} items, each {id, label}. The value is an option id, or a list of option ids.`,
+        "- default: optional, a value the field accepts, filled in when the form opens.",
+        `- submitLabel: optional label for the submit button, at most ${limits_1.ASK_LIMITS.submitLabelMaxLength} characters.`,
+        "- allowDecline: optional, default true (the user sees Skip).",
+        '- An accepted answer looks like {"action": "accept", "content": {"values": {"<field id>": <value>}}}. Optional fields the user left empty are left out.',
+    ].join("\n");
+};
+const filesRules = () => {
+    const { files } = limits_1.ASK_LIMITS;
+    return [
+        "ask_files: the user uploads one or more images or documents.",
+        '- accept: required list, each value once: "image" (JPEG, PNG, GIF, or WebP), "pdf", "text" (plain text), "csv", or "json".',
+        `- minFiles, maxFiles: optional whole numbers from ${files.minFiles} to ${files.maxFiles}. The user sends from minFiles (default ${files.minFiles}) to maxFiles (default ${files.maxFiles}) files.`,
+        `- submitLabel: optional label for the submit button, at most ${limits_1.ASK_LIMITS.submitLabelMaxLength} characters.`,
+        "- allowDecline: optional, default true (the user sees Skip).",
+        `- The answer lists each file's filename, mimeType, and size, and the tool result then shows you each file: images and PDFs as they are, and text, CSV, and JSON as text cut to ${files.textMaxBytes} bytes.`,
+    ].join("\n");
+};
+const KIND_RULES = {
+    choice: choiceRules,
+    confirm: confirmRules,
+    files: filesRules,
+    form: formRules,
+    markdown: markdownRules,
+};
+const COMPACT_KIND_RULES = {
+    choice: compactChoiceRules,
+    confirm: confirmRules,
+};
+const formatSection = ({ kindRules, kinds, shared, }) => {
+    if (kinds.length === 0) {
+        return "";
+    }
+    const toolNames = kinds.map((kind) => `ask_${kind}`).join(", ");
+    return [`Ask tools you can call: ${toolNames}.`, shared, ...kindRules].join("\n\n");
+};
+/**
+ * The system prompt section that describes the enabled ask kinds and their limits. Every number
+ * comes from `ASK_LIMITS`. With `surface: "compact"`, it lists only the kinds the compact surface
+ * offers, with their narrowed limits. Returns an empty string when no kinds are offered.
+ */
+const askPromptSection = ({ kinds, surface = "full", }) => {
+    const uniqueKinds = [...new Set(kinds)];
+    if (surface === "compact") {
+        const compactKinds = uniqueKinds.filter(schema_1.isCompactAskKind);
+        return formatSection({
+            kindRules: compactKinds.map((kind) => COMPACT_KIND_RULES[kind]()),
+            kinds: compactKinds,
+            shared: compactSharedRules(),
+        });
+    }
+    return formatSection({
+        kindRules: uniqueKinds.map((kind) => KIND_RULES[kind]()),
+        kinds: uniqueKinds,
+        shared: sharedRules(),
+    });
+};
+exports.askPromptSection = askPromptSection;