@terreno/blocks 57.10.1

package/dist/asks/files.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileNotOwnedError = exports.checkAskFileBytes = exports.fileTooLargeDraft = exports.sniffFileBytes = exports.base64ByteLength = exports.parseAskDataUrl = exports.isTextFileMimeType = exports.acceptedFileMimeTypes = exports.ASK_FILE_ACCEPT = exports.ASK_FILE_ACCEPT_MIME_TYPES = void 0;
+const errors_1 = require("./errors");
+/** What a `files` ask may accept, and the MIME types each value allows. */
+exports.ASK_FILE_ACCEPT_MIME_TYPES = {
+    csv: ["text/csv"],
+    image: ["image/jpeg", "image/png", "image/gif", "image/webp"],
+    json: ["application/json"],
+    pdf: ["application/pdf"],
+    text: ["text/plain"],
+};
+/** The values of a `files` ask's `accept` list, in the order the docs and prompt list them. */
+exports.ASK_FILE_ACCEPT = ["image", "pdf", "text", "csv", "json"];
+/** The MIME types an `accept` list allows, each listed once, in `accept` order. */
+const acceptedFileMimeTypes = (accept) => [
+    ...new Set(accept.flatMap((value) => exports.ASK_FILE_ACCEPT_MIME_TYPES[value])),
+];
+exports.acceptedFileMimeTypes = acceptedFileMimeTypes;
+const TEXT_MIME_TYPES = ["text/plain", "text/csv", "application/json"];
+/** Whether a file of this type reaches the model as text rather than as bytes. */
+const isTextFileMimeType = (mimeType) => TEXT_MIME_TYPES.includes(mimeType);
+exports.isTextFileMimeType = isTextFileMimeType;
+const BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+/**
+ * Splits a base64 `data:` URL into its media type (lowercase, without parameters) and payload.
+ * Returns undefined for anything else, including URL-encoded data URLs and remote URLs.
+ */
+const parseAskDataUrl = (url) => {
+    if (!url.startsWith("data:")) {
+        return undefined;
+    }
+    const comma = url.indexOf(",");
+    if (comma === -1) {
+        return undefined;
+    }
+    const params = url.slice("data:".length, comma).split(";");
+    if (params.length < 2 || params.at(-1)?.toLowerCase() !== "base64") {
+        return undefined;
+    }
+    const mediaType = params[0].trim().toLowerCase();
+    const base64 = url.slice(comma + 1);
+    if (mediaType === "" || base64.length % 4 !== 0 || !BASE64_PATTERN.test(base64)) {
+        return undefined;
+    }
+    return { base64, mediaType };
+};
+exports.parseAskDataUrl = parseAskDataUrl;
+/** The number of bytes a base64 payload decodes to. */
+const base64ByteLength = (base64) => {
+    const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+    return (base64.length / 4) * 3 - padding;
+};
+exports.base64ByteLength = base64ByteLength;
+const startsWith = (bytes, signature, offset = 0) => bytes.length >= offset + signature.length &&
+    signature.every((byte, index) => bytes[offset + index] === byte);
+const ascii = (text) => [...text].map((character) => character.charCodeAt(0));
+const decodeUtf8 = (bytes) => {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Reads a file's type from its first bytes. Images and PDFs are matched by their signatures;
+ * anything else that is valid UTF-8 with no NUL character is text.
+ */
+const sniffFileBytes = (bytes) => {
+    if (startsWith(bytes, [0xff, 0xd8, 0xff])) {
+        return "image/jpeg";
+    }
+    if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+        return "image/png";
+    }
+    if (startsWith(bytes, ascii("GIF87a")) || startsWith(bytes, ascii("GIF89a"))) {
+        return "image/gif";
+    }
+    if (startsWith(bytes, ascii("RIFF")) && startsWith(bytes, ascii("WEBP"), 8)) {
+        return "image/webp";
+    }
+    if (startsWith(bytes, ascii("%PDF-"))) {
+        return "application/pdf";
+    }
+    const text = decodeUtf8(bytes);
+    if (text === undefined || text.includes("\u0000")) {
+        return "unknown";
+    }
+    return "text";
+};
+exports.sniffFileBytes = sniffFileBytes;
+const isJson = (bytes) => {
+    try {
+        JSON.parse(decodeUtf8(bytes) ?? "");
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const bytesMatchType = (bytes, mimeType) => {
+    const sniffed = (0, exports.sniffFileBytes)(bytes);
+    if (!(0, exports.isTextFileMimeType)(mimeType)) {
+        return sniffed === mimeType;
+    }
+    if (sniffed !== "text") {
+        return false;
+    }
+    return mimeType !== "application/json" || isJson(bytes);
+};
+const describeSniffed = (bytes) => {
+    const sniffed = (0, exports.sniffFileBytes)(bytes);
+    if (sniffed === "text") {
+        return "text";
+    }
+    if (sniffed === "unknown") {
+        return "no accepted type";
+    }
+    return sniffed;
+};
+const oneDecimal = (value) => Math.round(value * 10) / 10;
+/** "512 bytes", "4.5 KB", or "10 MB". */
+const formatBytes = (bytes) => {
+    if (bytes < 1024) {
+        return bytes === 1 ? "1 byte" : `${bytes} bytes`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${oneDecimal(bytes / 1024)} KB`;
+    }
+    return `${oneDecimal(bytes / 1024 / 1024)} MB`;
+};
+const fileTooLargeDraft = ({ maxFileSizeBytes, segments, size, }) => ({
+    code: "FILE_TOO_LARGE",
+    fix: `Send a file of ${formatBytes(maxFileSizeBytes)} or less.`,
+    message: `The file is ${formatBytes(size)}, but the limit is ${formatBytes(maxFileSizeBytes)}.`,
+    segments,
+});
+exports.fileTooLargeDraft = fileTooLargeDraft;
+/**
+ * Checks the bytes of the file at `content.files[index]` on the server: they must fit the per-file
+ * cap and match the declared MIME type (a JSON file must also parse).
+ */
+const checkAskFileBytes = ({ bytes, index, maxFileSizeBytes, mimeType, }) => {
+    const segments = ["content", "files", index];
+    if (bytes.length > maxFileSizeBytes) {
+        return (0, errors_1.finalizeAskErrors)([
+            (0, exports.fileTooLargeDraft)({ maxFileSizeBytes, segments: [...segments, "size"], size: bytes.length }),
+        ]);
+    }
+    if (bytesMatchType(bytes, mimeType)) {
+        return [];
+    }
+    return (0, errors_1.finalizeAskErrors)([
+        {
+            code: "MIME_MISMATCH",
+            fix: `Send the file with its real type, or a file that is ${mimeType}.`,
+            message: `The file is declared as ${mimeType}, but its bytes are ${describeSniffed(bytes)}.`,
+            segments: [...segments, "mimeType"],
+        },
+    ]);
+};
+exports.checkAskFileBytes = checkAskFileBytes;
+/** The error for a `fileId` that the caller did not upload, or that the host cannot load. */
+const fileNotOwnedError = ({ index }) => ({
+    code: "FILE_NOT_OWNED",
+    fix: "Upload the file with POST /files/upload and send the id it returns, or send a data: URL.",
+    message: "The file id does not name one of your uploads.",
+    path: (0, errors_1.formatAskPath)(["content", "files", index, "fileId"]),
+});
+exports.fileNotOwnedError = fileNotOwnedError;

package/dist/asks/formValues.d.ts

@@ -0,0 +1,32 @@
+import { type AskErrorDraft } from "./errors";
+import type { FormAskInput, FormField } from "./schema";
+/** A value a form answer holds for one field. */
+export type FormValue = boolean | number | string | string[];
+/** The longest value a field accepts, in UTF-16 code units. */
+export declare const formTextMaxLength: (field: FormField) => number;
+/**
+ * Whether a value counts as unanswered: a string with no visible characters, or an empty list.
+ * `false` and `0` are answers.
+ */
+export declare const isBlankFormValue: (value: unknown) => boolean;
+interface CheckContext {
+    field: FormField;
+    /** True when the value is the field's `default` in an ask, not a user's answer. */
+    isDefault: boolean;
+    segments: readonly PropertyKey[];
+}
+/**
+ * Checks one present value against its field: its JSON type, then the type's own rules (length,
+ * format, range, calendar date, offered options). Used for every answer value and every default,
+ * so a default is always a value the field accepts. Blank values are the caller's concern, except
+ * that a blank default string fails with `TOO_SHORT`.
+ */
+export declare const checkFormValue: ({ field, isDefault, segments, value, }: CheckContext & {
+    value: unknown;
+}) => AskErrorDraft[];
+/**
+ * The values a form starts with: each field's `default`, keyed by field id. Fields without a
+ * default are left out.
+ */
+export declare const formDefaultValues: (input: FormAskInput) => Record<string, FormValue>;
+export {};

package/dist/asks/formValues.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formDefaultValues = exports.checkFormValue = exports.isBlankFormValue = exports.formTextMaxLength = void 0;
+const zod_1 = require("zod");
+const errors_1 = require("./errors");
+const limits_1 = require("./limits");
+const emailSchema = zod_1.z.email();
+const urlSchema = zod_1.z.url({ protocol: /^https?$/ });
+const PHONE_CHARACTERS = /^\+?[0-9 ().-]+$/;
+const NON_DIGITS = /\D/g;
+/** The ISO 8601 shape each date field type takes, with an example for fixes. */
+const DATE_FORMATS = {
+    date: { example: "2026-10-01", format: "YYYY-MM-DD", schema: zod_1.z.iso.date() },
+    datetime: {
+        example: "2026-10-01T09:30:00Z",
+        format: "an ISO 8601 date and time with Z or an offset such as +02:00 (seconds optional)",
+        schema: zod_1.z.union([
+            zod_1.z.iso.datetime({ offset: true, precision: -1 }),
+            zod_1.z.iso.datetime({ offset: true }),
+        ]),
+    },
+    time: { example: "09:30", format: "HH:mm (24-hour)", schema: zod_1.z.iso.time({ precision: -1 }) },
+};
+const TYPE_NAMES = {
+    boolean: "true or false",
+    date: "a date string",
+    datetime: "a datetime string",
+    email: "an email address",
+    multiselect: "a list of option ids",
+    number: "a number",
+    phone: "a phone number",
+    select: "an option id",
+    text: "a string",
+    textarea: "a string",
+    time: "a time string",
+    url: "an http or https URL",
+};
+const characters = (count) => (count === 1 ? "1 character" : `${count} characters`);
+/** The longest value a field accepts, in UTF-16 code units. */
+const formTextMaxLength = (field) => {
+    if (field.type === "textarea") {
+        return field.maxLength ?? limits_1.ASK_LIMITS.form.textareaMaxLength;
+    }
+    if (field.type === "text") {
+        return field.maxLength ?? limits_1.ASK_LIMITS.form.textMaxLength;
+    }
+    return limits_1.ASK_LIMITS.form.textMaxLength;
+};
+exports.formTextMaxLength = formTextMaxLength;
+/**
+ * Whether a value counts as unanswered: a string with no visible characters, or an empty list.
+ * `false` and `0` are answers.
+ */
+const isBlankFormValue = (value) => (typeof value === "string" && value.trim() === "") ||
+    (Array.isArray(value) && value.length === 0);
+exports.isBlankFormValue = isBlankFormValue;
+const draft = ({ segments }, code, message, fix) => ({ code, fix, message, segments });
+const mismatch = (context, detail) => {
+    const path = (0, errors_1.formatAskPath)(context.segments);
+    const expected = TYPE_NAMES[context.field.type];
+    return draft(context, "FIELD_TYPE_MISMATCH", detail ??
+        `${path} must be ${expected} for the ${context.field.type} field "${context.field.id}".`, `Make ${path} ${expected}.`);
+};
+const checkLength = (context, value) => {
+    const path = (0, errors_1.formatAskPath)(context.segments);
+    const max = (0, exports.formTextMaxLength)(context.field);
+    const drafts = [];
+    if (value.length > max) {
+        drafts.push(draft(context, "TOO_LONG", `${path} is ${characters(value.length)}, but the field allows at most ${max}.`, `Shorten ${path} to ${characters(max)} or fewer.`));
+    }
+    const { field } = context;
+    const min = field.type === "text" || field.type === "textarea" ? (field.minLength ?? 0) : 0;
+    const visibleLength = value.trim().length;
+    if (visibleLength === 0 && context.isDefault) {
+        drafts.push(draft(context, "TOO_SHORT", `${path} must contain visible text.`, `Write at least one visible character in ${path}, or remove it.`));
+    }
+    else if (visibleLength < min) {
+        drafts.push(draft(context, "TOO_SHORT", `${path} is ${characters(visibleLength)}, but the field needs at least ${min}.`, `Write at least ${characters(min)} in ${path}.`));
+    }
+    return drafts;
+};
+const checkStringFormat = (context, value) => {
+    const path = (0, errors_1.formatAskPath)(context.segments);
+    const { type } = context.field;
+    if (type === "email" && !emailSchema.safeParse(value).success) {
+        return [mismatch(context, `${path} ${(0, errors_1.quoteValue)(value)} is not a valid email address.`)];
+    }
+    if (type === "url" && !urlSchema.safeParse(value).success) {
+        return [mismatch(context, `${path} ${(0, errors_1.quoteValue)(value)} is not an http or https URL.`)];
+    }
+    if (type === "phone") {
+        const digits = value.replace(NON_DIGITS, "").length;
+        const { phoneDigitsMax, phoneDigitsMin } = limits_1.ASK_LIMITS.form;
+        if (!PHONE_CHARACTERS.test(value) || digits < phoneDigitsMin || digits > phoneDigitsMax) {
+            return [
+                draft(context, "FIELD_TYPE_MISMATCH", `${path} ${(0, errors_1.quoteValue)(value)} is not a valid phone number.`, `Make ${path} ${phoneDigitsMin}-${phoneDigitsMax} digits, optionally starting with "+", with only spaces, dots, dashes, or parentheses between them.`),
+            ];
+        }
+    }
+    return [];
+};
+const checkNumber = (context, value) => {
+    const { field } = context;
+    if (field.type !== "number") {
+        return [];
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return [mismatch(context)];
+    }
+    const path = (0, errors_1.formatAskPath)(context.segments);
+    if (field.integer === true && !Number.isInteger(value)) {
+        return [
+            draft(context, "FIELD_TYPE_MISMATCH", `${path} is ${value}, but the field takes whole numbers only.`, `Make ${path} a whole number.`),
+        ];
+    }
+    if (field.min !== undefined && value < field.min) {
+        return [
+            draft(context, "OUT_OF_RANGE", `${path} is ${value}, below the field's min of ${field.min}.`, `Make ${path} at least ${field.min}.`),
+        ];
+    }
+    if (field.max !== undefined && value > field.max) {
+        return [
+            draft(context, "OUT_OF_RANGE", `${path} is ${value}, above the field's max of ${field.max}.`, `Make ${path} at most ${field.max}.`),
+        ];
+    }
+    return [];
+};
+const notOffered = (context, id, segments) => context.isDefault
+    ? {
+        code: "DEFAULT_NOT_IN_OPTIONS",
+        fix: `Use an id from fields[${String(context.segments[1])}].options, or remove it from the default.`,
+        message: `Default ${(0, errors_1.quoteValue)(id)} is not the id of any option of the field.`,
+        segments,
+    }
+    : {
+        code: "OPTION_NOT_OFFERED",
+        fix: `Use the id of one of the options of the field "${context.field.id}".`,
+        message: `${(0, errors_1.quoteValue)(id)} is not one of the field's options.`,
+        segments,
+    };
+const checkOptions = (context, value) => {
+    const { field } = context;
+    if (field.type !== "select" && field.type !== "multiselect") {
+        return [];
+    }
+    const offered = new Set(field.options.map((option) => option.id));
+    if (field.type === "select") {
+        if (typeof value !== "string") {
+            return [mismatch(context)];
+        }
+        return offered.has(value) ? [] : [notOffered(context, value, [...context.segments])];
+    }
+    if (!Array.isArray(value) || value.some((id) => typeof id !== "string")) {
+        return [mismatch(context)];
+    }
+    const path = (0, errors_1.formatAskPath)(context.segments);
+    if (value.length > limits_1.ASK_LIMITS.choice.optionsMax) {
+        return [
+            draft(context, "TOO_MANY", `${path} has more than ${limits_1.ASK_LIMITS.choice.optionsMax} items.`, `Remove items from ${path} until it has ${limits_1.ASK_LIMITS.choice.optionsMax} or fewer.`),
+        ];
+    }
+    const firstIndexById = new Map();
+    return value.flatMap((id, index) => {
+        const segments = [...context.segments, index];
+        const firstIndex = firstIndexById.get(id);
+        if (firstIndex !== undefined) {
+            return [
+                {
+                    code: "DUPLICATE_ID",
+                    fix: `List each option id in ${path} once.`,
+                    message: `${(0, errors_1.quoteValue)(id)} is already listed at ${(0, errors_1.formatAskPath)([...context.segments, firstIndex])}.`,
+                    segments,
+                },
+            ];
+        }
+        firstIndexById.set(id, index);
+        return offered.has(id) ? [] : [notOffered(context, id, segments)];
+    });
+};
+/**
+ * Checks one present value against its field: its JSON type, then the type's own rules (length,
+ * format, range, calendar date, offered options). Used for every answer value and every default,
+ * so a default is always a value the field accepts. Blank values are the caller's concern, except
+ * that a blank default string fails with `TOO_SHORT`.
+ */
+const checkFormValue = ({ field, isDefault, segments, value, }) => {
+    const context = { field, isDefault, segments };
+    switch (field.type) {
+        case "boolean":
+            return typeof value === "boolean" ? [] : [mismatch(context)];
+        case "number":
+            return checkNumber(context, value);
+        case "select":
+        case "multiselect":
+            return checkOptions(context, value);
+        case "date":
+        case "time":
+        case "datetime": {
+            if (typeof value !== "string") {
+                return [mismatch(context)];
+            }
+            const { example, format, schema } = DATE_FORMATS[field.type];
+            if (schema.safeParse(value).success) {
+                return [];
+            }
+            const path = (0, errors_1.formatAskPath)(segments);
+            return [
+                draft(context, "INVALID_DATE", `${path} ${(0, errors_1.quoteValue)(value)} is not a real ${field.type} in ${format}.`, `Write ${path} as ${format}, such as "${example}".`),
+            ];
+        }
+        default: {
+            if (typeof value !== "string") {
+                return [mismatch(context)];
+            }
+            const lengthDrafts = checkLength(context, value);
+            if (lengthDrafts.length > 0 || value.trim() === "") {
+                return lengthDrafts;
+            }
+            return checkStringFormat(context, value);
+        }
+    }
+};
+exports.checkFormValue = checkFormValue;
+/**
+ * The values a form starts with: each field's `default`, keyed by field id. Fields without a
+ * default are left out.
+ */
+const formDefaultValues = (input) => Object.fromEntries(input.fields.flatMap((field) => field.default === undefined ? [] : [[field.id, field.default]]));
+exports.formDefaultValues = formDefaultValues;

package/dist/asks/headless.d.ts

@@ -0,0 +1,227 @@
+import { z } from "zod";
+export declare const askSurfaceSchema: z.ZodEnum<{
+    full: "full";
+    compact: "compact";
+}>;
+/** An answer to a pending ask: the answer envelope plus the ask's `toolCallId`. */
+export declare const askResponseWithToolCallIdSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"accept">;
+    content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    toolCallId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"decline">;
+    toolCallId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"cancel">;
+    reason: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodString;
+}, z.core.$strict>], "action">;
+export type AskResponseWithToolCallId = z.infer<typeof askResponseWithToolCallIdSchema>;
+/** The body of `POST /gpt/histories/:id/turn`. */
+export declare const turnRequestSchema: z.ZodObject<{
+    askResponse: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"accept">;
+        content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"decline">;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"cancel">;
+        reason: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>], "action">>;
+    buttonId: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    surface: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        compact: "compact";
+    }>>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TurnRequest = z.infer<typeof turnRequestSchema>;
+export declare const pendingAskSummarySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        markdown: "markdown";
+        files: "files";
+        choice: "choice";
+        confirm: "confirm";
+        form: "form";
+    }>;
+    simple: z.ZodObject<{
+        buttons: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                action: z.ZodLiteral<"accept">;
+                content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"decline">;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"cancel">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "action">;
+            style: z.ZodEnum<{
+                primary: "primary";
+                destructive: "destructive";
+                default: "default";
+                cancel: "cancel";
+            }>;
+        }, z.core.$strict>>;
+        handoff: z.ZodBoolean;
+        kind: z.ZodEnum<{
+            markdown: "markdown";
+            files: "files";
+            choice: "choice";
+            confirm: "confirm";
+            form: "form";
+        }>;
+        text: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>;
+    toolCallId: z.ZodString;
+}, z.core.$strict>;
+export type PendingAskSummary = z.infer<typeof pendingAskSummarySchema>;
+/** What `POST /gpt/histories/:id/turn` returns in `data` once the turn finishes. */
+export declare const turnResultSchema: z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    historyId: z.ZodString;
+    pendingAsk: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            markdown: "markdown";
+            files: "files";
+            choice: "choice";
+            confirm: "confirm";
+            form: "form";
+        }>;
+        simple: z.ZodObject<{
+            buttons: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    action: z.ZodLiteral<"accept">;
+                    content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"decline">;
+                }, z.core.$strict>, z.ZodObject<{
+                    action: z.ZodLiteral<"cancel">;
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>], "action">;
+                style: z.ZodEnum<{
+                    primary: "primary";
+                    destructive: "destructive";
+                    default: "default";
+                    cancel: "cancel";
+                }>;
+            }, z.core.$strict>>;
+            handoff: z.ZodBoolean;
+            kind: z.ZodEnum<{
+                markdown: "markdown";
+                files: "files";
+                choice: "choice";
+                confirm: "confirm";
+                form: "form";
+            }>;
+            text: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            toolCallId: z.ZodString;
+        }, z.core.$strict>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>>;
+    text: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TurnResult = z.infer<typeof turnResultSchema>;
+export declare const pendingAskListItemSchema: z.ZodObject<{
+    created: z.ZodISODateTime;
+    historyId: z.ZodString;
+    kind: z.ZodEnum<{
+        markdown: "markdown";
+        files: "files";
+        choice: "choice";
+        confirm: "confirm";
+        form: "form";
+    }>;
+    simple: z.ZodObject<{
+        buttons: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                action: z.ZodLiteral<"accept">;
+                content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"decline">;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"cancel">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "action">;
+            style: z.ZodEnum<{
+                primary: "primary";
+                destructive: "destructive";
+                default: "default";
+                cancel: "cancel";
+            }>;
+        }, z.core.$strict>>;
+        handoff: z.ZodBoolean;
+        kind: z.ZodEnum<{
+            markdown: "markdown";
+            files: "files";
+            choice: "choice";
+            confirm: "confirm";
+            form: "form";
+        }>;
+        text: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>;
+    title: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodString;
+}, z.core.$strict>;
+export type PendingAskListItem = z.infer<typeof pendingAskListItemSchema>;
+/** What `GET /gpt/histories/pendingAsks` returns in `data`: the caller's pending asks, newest first. */
+export declare const pendingAskListSchema: z.ZodArray<z.ZodObject<{
+    created: z.ZodISODateTime;
+    historyId: z.ZodString;
+    kind: z.ZodEnum<{
+        markdown: "markdown";
+        files: "files";
+        choice: "choice";
+        confirm: "confirm";
+        form: "form";
+    }>;
+    simple: z.ZodObject<{
+        buttons: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                action: z.ZodLiteral<"accept">;
+                content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"decline">;
+            }, z.core.$strict>, z.ZodObject<{
+                action: z.ZodLiteral<"cancel">;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "action">;
+            style: z.ZodEnum<{
+                primary: "primary";
+                destructive: "destructive";
+                default: "default";
+                cancel: "cancel";
+            }>;
+        }, z.core.$strict>>;
+        handoff: z.ZodBoolean;
+        kind: z.ZodEnum<{
+            markdown: "markdown";
+            files: "files";
+            choice: "choice";
+            confirm: "confirm";
+            form: "form";
+        }>;
+        text: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+    }, z.core.$strict>;
+    title: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodString;
+}, z.core.$strict>>;