@teaflask/assistant 0.7.0 → 0.8.0

package/dist/affordances/prefill.js

@@ -1,26 +1,15 @@
+import { settledValueOf, theClickWouldSubmitOrLeaveThePage, theControlIsInert, typeLikeAUser, } from "./page-gestures.js";
+import { CHECKBOX_VALUE_REASON, CONTROL_REDRAWN_REASON, EDITOR_UNAVAILABLE_REASON, FILE_FIELD_REASON, INERT_FIELD_REASON, MIRROR_INPUT_REASON, MULTI_CHOICE_REASON, noMatchingOptionReasonListing, NOT_FILLABLE_REASON, RADIO_VALUE_REASON, reportListingBudget, SECRET_FIELD_REASON, SUBMITTING_CONTROL_REASON, unavailableOptionReason, VALUE_DID_NOT_LAND_REASON, } from "./prefill-reasons.js";
 import { theFieldHoldsASecret } from "../reader/redaction.js";
-import { resolvedElementOfRef } from "../reader/snapshot.js";
-import { isContentEditableElement } from "../reader/roles.js";
-const SECRET_FIELD_REASON = "This field holds a secret (a password or payment detail) — the user " +
-    "must type it themselves.";
-const FILE_FIELD_REASON = "File pickers cannot be filled by the assistant — the user must choose " +
-    "the file themselves.";
-const INERT_FIELD_REASON = "This field is disabled or read-only and cannot take a value right now.";
-const NOT_FILLABLE_REASON = "This element is not a fillable form field — take a fresh read and " +
-    "pick a textbox, dropdown, checkbox, or editor ref.";
-const CHECKBOX_VALUE_REASON = 'A checkbox takes "true" or "false", nothing else.';
-const RADIO_VALUE_REASON = 'A radio button can only be selected — pass "true" on the option to ' +
-    "select instead.";
-const NO_MATCHING_OPTION_REASON = "No option in this dropdown matches that value — read the page to see " +
-    "the options it offers.";
-const VALUE_DID_NOT_LAND_REASON = "The page's own scripts rejected this value — it did not stay in the " +
-    "field.";
-const EDITOR_UNAVAILABLE_REASON = "This editor cannot be filled on this page — tell the user what to " +
-    "type instead.";
-export function prefilledFieldsReport(fields) {
+import { renderedOptionTextOf } from "../reader/render.js";
+import { lastReadIgnoreSelectors, resolvedElementOfRef, } from "../reader/snapshot.js";
+import { theElementSitsInACuratedSubtree } from "../reader/snapshot-root.js";
+import { isContentEditableElement, roleOf, theControlIsDisabled, } from "../reader/roles.js";
+export async function prefilledFieldsReport(fields, probe) {
     const report = { filled: [], refused: [] };
+    const listingBudget = reportListingBudget();
     for (const field of fields) {
-        const refusal = _filledFieldRefusalOf(field);
+        const refusal = await _filledFieldRefusalOf(field, probe, listingBudget);
         if (refusal === null) {
             report.filled.push(field.refId);
         }
@@ -30,26 +19,52 @@ export function prefilledFieldsReport(fields) {
     }
     return report;
 }
-function _filledFieldRefusalOf(field) {
+async function _filledFieldRefusalOf(field, probe, listingBudget) {
     const resolved = resolvedElementOfRef(field.refId);
     if (resolved.error !== null) {
         return resolved.error;
     }
     const element = resolved.element;
     if (element instanceof HTMLInputElement) {
-        return _inputRefusalOf(element, field.value);
+        return _inputRefusalOf(element, field.value, probe, listingBudget);
     }
     if (element instanceof HTMLTextAreaElement) {
         return _textAreaRefusalOf(element, field.value);
     }
     if (element instanceof HTMLSelectElement) {
-        return _selectRefusalOf(element, field.value);
+        return _selectRefusalOf(element, field.value, listingBudget);
     }
     if (isContentEditableElement(element)) {
         return _editorRefusalOf(element, field.value);
     }
+    if (_isAriaToggle(element)) {
+        const { ariaToggleRefusalOf } = await import("./aria-toggles.js");
+        return ariaToggleRefusalOf(element, field.value);
+    }
+    if (_isCustomDropdown(element)) {
+        const { customDropdownRefusalOf } = await import("./aria-dropdowns.js");
+        return customDropdownRefusalOf(element, field.value, probe, listingBudget);
+    }
+    if (_isStandingListbox(element)) {
+        const { listboxPickRefusalOf } = await import("./aria-dropdowns.js");
+        return listboxPickRefusalOf(element, field.value, probe, listingBudget);
+    }
     return NOT_FILLABLE_REASON;
 }
+const _TOGGLE_ROLES = new Set(["checkbox", "radio", "switch"]);
+function _isAriaToggle(element) {
+    return _TOGGLE_ROLES.has(roleOf(element));
+}
+function _isCustomDropdown(element) {
+    if (element instanceof HTMLSelectElement) {
+        return false;
+    }
+    return (roleOf(element) === "combobox" ||
+        (element.getAttribute("aria-haspopup") ?? "").toLowerCase() === "listbox");
+}
+function _isStandingListbox(element) {
+    return roleOf(element) === "listbox";
+}
 const _NOT_A_FIELD_INPUT_TYPES = new Set([
     "hidden",
     "submit",
@@ -57,7 +72,7 @@ const _NOT_A_FIELD_INPUT_TYPES = new Set([
     "reset",
     "image",
 ]);
-function _inputRefusalOf(input, value) {
+async function _inputRefusalOf(input, value, probe, listingBudget) {
     if (input.type === "password" || theFieldHoldsASecret(input)) {
         return SECRET_FIELD_REASON;
     }
@@ -67,59 +82,105 @@ function _inputRefusalOf(input, value) {
     if (_NOT_A_FIELD_INPUT_TYPES.has(input.type)) {
         return NOT_FILLABLE_REASON;
     }
-    if (input.disabled || input.readOnly) {
+    const isComboboxInput = roleOf(input) === "combobox";
+    if (theControlIsInert(input) ||
+        input.disabled ||
+        (input.readOnly && !isComboboxInput)) {
         return INERT_FIELD_REASON;
     }
     if (input.type === "checkbox" || input.type === "radio") {
+        if (input.getAttribute("aria-hidden") === "true") {
+            return MIRROR_INPUT_REASON;
+        }
         return _checkedRefusalOf(input, value);
     }
-    _setThroughThePrototype(input, value);
-    _announceTheEdit(input);
-    return input.value === value ? null : VALUE_DID_NOT_LAND_REASON;
+    if (isComboboxInput) {
+        const { customDropdownRefusalOf } = await import("./aria-dropdowns.js");
+        return customDropdownRefusalOf(input, value, probe, listingBudget, async (fallbackReason) => input.readOnly
+            ? fallbackReason
+            : _typedValueRefusalOf(input, value, () => input.value));
+    }
+    return _typedValueRefusalOf(input, value, () => input.value);
 }
-function _checkedRefusalOf(input, value) {
-    if (value !== "true" && value !== "false") {
-        return CHECKBOX_VALUE_REASON;
+async function _typedValueRefusalOf(control, value, read) {
+    typeLikeAUser(control, value);
+    const landed = (await settledValueOf(read)) === value;
+    if (!control.isConnected) {
+        return CONTROL_REDRAWN_REASON;
     }
-    if (input.type === "radio" && value === "false") {
+    return landed ? null : VALUE_DID_NOT_LAND_REASON;
+}
+async function _checkedRefusalOf(input, value) {
+    if (input.type === "radio" && value !== "true") {
         return RADIO_VALUE_REASON;
     }
+    if (value !== "true" && value !== "false") {
+        return CHECKBOX_VALUE_REASON;
+    }
     const desired = value === "true";
-    if (input.checked !== desired) {
-        input.click();
+    if (input.checked === desired) {
+        return null;
+    }
+    if (theClickWouldSubmitOrLeaveThePage(input)) {
+        return SUBMITTING_CONTROL_REASON;
     }
-    return input.checked === desired ? null : VALUE_DID_NOT_LAND_REASON;
+    input.click();
+    const landed = (await settledValueOf(() => input.checked)) === desired;
+    if (!input.isConnected) {
+        return CONTROL_REDRAWN_REASON;
+    }
+    return landed ? null : VALUE_DID_NOT_LAND_REASON;
 }
-function _textAreaRefusalOf(textArea, value) {
+async function _textAreaRefusalOf(textArea, value) {
     if (theFieldHoldsASecret(textArea)) {
         return SECRET_FIELD_REASON;
     }
-    if (textArea.disabled || textArea.readOnly) {
+    if (theControlIsInert(textArea) || textArea.disabled || textArea.readOnly) {
         return INERT_FIELD_REASON;
     }
-    _setThroughThePrototype(textArea, value);
-    _announceTheEdit(textArea);
-    return textArea.value === value ? null : VALUE_DID_NOT_LAND_REASON;
+    return _typedValueRefusalOf(textArea, value, () => textArea.value);
 }
-function _selectRefusalOf(select, value) {
-    if (select.disabled) {
+async function _selectRefusalOf(select, value, listingBudget) {
+    if (theControlIsInert(select) || select.disabled) {
         return INERT_FIELD_REASON;
     }
+    if (select.multiple) {
+        return MULTI_CHOICE_REASON;
+    }
     const option = _optionMatching(select, value);
     if (option === null) {
-        return NO_MATCHING_OPTION_REASON;
+        const labels = _matchableOptionsOf(select)
+            .filter((candidate) => !theControlIsDisabled(candidate, "option"))
+            .map((candidate) => candidate.label.trim());
+        return noMatchingOptionReasonListing(labels, listingBudget);
+    }
+    if (select.value === option.value) {
+        return null;
     }
-    _setThroughThePrototype(select, option.value);
-    _announceTheEdit(select);
-    return select.value === option.value ? null : VALUE_DID_NOT_LAND_REASON;
+    if (theControlIsDisabled(option, "option")) {
+        return unavailableOptionReason(option.label.trim());
+    }
+    return _typedValueRefusalOf(select, option.value, () => select.value);
 }
 function _optionMatching(select, value) {
-    const options = Array.from(select.options);
+    const options = _matchableOptionsOf(select);
     return (options.find((option) => option.value === value) ??
         options.find((option) => option.label.trim() === value.trim()) ??
+        options.find((option) => {
+            const shownToTheModel = renderedOptionTextOf(option);
+            const full = option.text.replace(/\s+/g, " ").trim();
+            return (shownToTheModel !== full && shownToTheModel.trimEnd() === value.trim());
+        }) ??
         null);
 }
-function _editorRefusalOf(element, value) {
+function _matchableOptionsOf(select) {
+    const ignoreSelectors = lastReadIgnoreSelectors();
+    return Array.from(select.options).filter((option) => !theElementSitsInACuratedSubtree(option, ignoreSelectors));
+}
+async function _editorRefusalOf(element, value) {
+    if (theControlIsInert(element)) {
+        return INERT_FIELD_REASON;
+    }
     if (!(element instanceof HTMLElement)) {
         return EDITOR_UNAVAILABLE_REASON;
     }
@@ -133,19 +194,9 @@ function _editorRefusalOf(element, value) {
     }
     selection.selectAllChildren(element);
     document.execCommand("insertText", false, value);
-    const landed = element.textContent.includes(value);
-    return landed ? null : VALUE_DID_NOT_LAND_REASON;
-}
-function _setThroughThePrototype(control, value) {
-    const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(control), "value");
-    if (descriptor?.set !== undefined) {
-        descriptor.set.call(control, value);
+    const landed = await settledValueOf(() => element.textContent.includes(value));
+    if (!element.isConnected) {
+        return CONTROL_REDRAWN_REASON;
     }
-    else {
-        control.value = value;
-    }
-}
-function _announceTheEdit(control) {
-    control.dispatchEvent(new Event("input", { bubbles: true }));
-    control.dispatchEvent(new Event("change", { bubbles: true }));
+    return landed ? null : VALUE_DID_NOT_LAND_REASON;
 }

package/dist/components/tool-views/action-values.js

@@ -0,0 +1,43 @@
+import { prettyPrintParameters } from "../pretty-print.js";
+import { CARD_BLOCK_CLASS } from "./parts-classes.js";
+import { el, factRows, recordOf, scrollRegion } from "./view-dom.js";
+const VALUE_PANE_CLASS = "tf:m-0 tf:whitespace-pre-wrap tf:font-mono tf:text-xs tf:text-tf-card-foreground";
+export function valueRows(value) {
+    const record = recordOf(value);
+    if (record !== null) {
+        return scrollRegion([
+            factRows(Object.entries(record).map(([key, entry]) => [key, _valueOf(entry)])),
+        ]);
+    }
+    return valueBlock(value);
+}
+export function valueBlock(value) {
+    const wrapper = el("div", CARD_BLOCK_CLASS);
+    wrapper.dataset.tfActionValueBlock = "";
+    wrapper.append(el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value)));
+    return scrollRegion([wrapper]);
+}
+function _valueOf(value) {
+    if (typeof value === "string") {
+        return value === "" ? "—" : value;
+    }
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint") {
+        return String(value);
+    }
+    if (value === null || value === undefined) {
+        return "—";
+    }
+    return el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value));
+}
+export function statusBadgeOf(status) {
+    const badge = el("span", status >= 400
+        ? "tf:font-medium tf:text-tf-destructive"
+        : "tf:text-tf-muted-foreground", `HTTP ${String(status)}`);
+    badge.dataset.tfActionStatus = String(status);
+    return badge;
+}
+export function isEmptyBody(body) {
+    return body === undefined || body === null || body === "";
+}

package/dist/components/tool-views/action-view.js

@@ -1,12 +1,10 @@
-import { prettyPrintParameters } from "../pretty-print.js";
-import { CARD_BLOCK_CLASS } from "./parts-classes.js";
-import { actionEnvelopeOf, actionFailureOf, captionRow, card, el, factRows, note, recordOf, scrollRegion, settledOutcomeNotesOf, settledWithResult, statelessToolView, } from "./view-dom.js";
+import { isEmptyBody, statusBadgeOf, valueRows } from "./action-values.js";
+import { actionEnvelopeOf, actionFailureOf, captionRow, card, el, factRows, note, recordOf, settledOutcomeNotesOf, settledWithResult, statelessToolView, } from "./view-dom.js";
 const REQUEST_SECTIONS = [
     ["path_params", "Path parameters"],
     ["query", "Query"],
     ["body", "Body"],
 ];
-const VALUE_PANE_CLASS = "tf:m-0 tf:whitespace-pre-wrap tf:font-mono tf:text-xs tf:text-tf-card-foreground";
 export const actionToolView = statelessToolView(_renderAction);
 function _renderAction({ call }) {
     const root = el("div", "tf:flex tf:flex-col tf:gap-2");
@@ -21,7 +19,7 @@ function _renderAction({ call }) {
         if (record !== null && Object.keys(record).length === 0) {
             continue;
         }
-        sections.push(captionRow(label), _valueRows(value));
+        sections.push(captionRow(label), valueRows(value));
     }
     if (sections.length > 0) {
         root.append(card(sections));
@@ -52,32 +50,6 @@ function _appendFieldProblems(root, call) {
     }
     root.append(card(parts));
 }
-function _valueRows(value) {
-    const record = recordOf(value);
-    if (record !== null) {
-        return scrollRegion([
-            factRows(Object.entries(record).map(([key, entry]) => [key, _valueOf(entry)])),
-        ]);
-    }
-    const wrapper = el("div", CARD_BLOCK_CLASS);
-    wrapper.dataset.tfActionValueBlock = "";
-    wrapper.append(el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value)));
-    return scrollRegion([wrapper]);
-}
-function _valueOf(value) {
-    if (typeof value === "string") {
-        return value === "" ? "—" : value;
-    }
-    if (typeof value === "number" ||
-        typeof value === "boolean" ||
-        typeof value === "bigint") {
-        return String(value);
-    }
-    if (value === null || value === undefined) {
-        return "—";
-    }
-    return el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value));
-}
 function _appendResponse(root, call) {
     if (call.resultText === undefined) {
         return;
@@ -88,24 +60,16 @@ function _appendResponse(root, call) {
         return;
     }
     const rows = [];
-    let status;
-    if (envelope.status !== null) {
-        status = el("span", envelope.status >= 400
-            ? "tf:font-medium tf:text-tf-destructive"
-            : "tf:text-tf-muted-foreground", `HTTP ${String(envelope.status)}`);
-        status.dataset.tfActionStatus = String(envelope.status);
-    }
+    const status = envelope.status === null ? undefined : statusBadgeOf(envelope.status);
     rows.push(captionRow(envelope.truncated ? "Response (truncated)" : "Response", status));
     if (envelope.truncated) {
         rows.push(captionRow("The response body was truncated by the client to fit the size cap."));
     }
-    if (envelope.body === undefined ||
-        envelope.body === null ||
-        envelope.body === "") {
+    if (isEmptyBody(envelope.body)) {
         rows.push(captionRow("Empty response body."));
     }
     else {
-        rows.push(_valueRows(envelope.body));
+        rows.push(valueRows(envelope.body));
     }
     root.append(card(rows));
 }

package/dist/components/tool-views/graphql-action-view.js

@@ -0,0 +1,95 @@
+import { prettyPrintParameters } from "../pretty-print.js";
+import { isEmptyBody, statusBadgeOf, valueBlock, valueRows, } from "./action-values.js";
+import { actionEnvelopeOf, captionRow, card, el, factRows, note, recordOf, settledOutcomeNotesOf, scrollRegion, settledWithResult, statelessToolView, } from "./view-dom.js";
+export const graphqlActionToolView = statelessToolView(_renderGraphQLAction);
+function _renderGraphQLAction({ call }) {
+    const root = el("div", "tf:flex tf:flex-col tf:gap-2");
+    root.dataset.tfGraphqlActionView = "";
+    const variables = recordOf(call.args.variables);
+    if (variables !== null && Object.keys(variables).length > 0) {
+        root.append(card([captionRow("Variables"), _valuesOf(variables)]));
+    }
+    root.append(...settledOutcomeNotesOf(call));
+    if (settledWithResult(call)) {
+        _appendResponse(root, call);
+    }
+    return root;
+}
+function _appendResponse(root, call) {
+    const envelope = actionEnvelopeOf(call.resultText);
+    if (envelope === null) {
+        root.append(note("The response couldn't be read as an action result and isn't rendered."));
+        return;
+    }
+    const response = recordOf(envelope.body);
+    const errors = Array.isArray(response?.errors) ? response.errors : [];
+    const graphqlShaped = _readsAsGraphQLResponse(response, errors);
+    const rows = [
+        captionRow(envelope.truncated ? "Response (truncated)" : "Response", _statusOf(envelope.status)),
+    ];
+    if (envelope.truncated) {
+        rows.push(captionRow(_cutSentenceOf(graphqlShaped, errors, response)));
+    }
+    if (response === null || !graphqlShaped) {
+        rows.push(isEmptyBody(envelope.body)
+            ? captionRow("Empty response body.")
+            : valueRows(envelope.body));
+        root.append(card(rows));
+        return;
+    }
+    if (errors.length > 0) {
+        rows.push(_errorsCaption(errors.length), _errorRows(errors));
+    }
+    const hasData = response.data !== null && response.data !== undefined;
+    rows.push(hasData ? captionRow("Data") : captionRow("Data", "none"));
+    if (hasData) {
+        rows.push(_valuesOf(_withoutCutMarker(response.data)));
+    }
+    root.append(card(rows));
+}
+function _readsAsGraphQLResponse(response, errors) {
+    return response !== null && (errors.length > 0 || "data" in response);
+}
+function _statusOf(status) {
+    return status === null || status === 200 ? undefined : statusBadgeOf(status);
+}
+function _cutSentenceOf(graphqlShaped, errors, response) {
+    if (!graphqlShaped || errors.length === 0) {
+        return "Too large to show in full: the response is shortened.";
+    }
+    return typeof response?.data === "string"
+        ? "Too large to show in full: the data is shortened and any other response fields dropped; the errors are complete."
+        : "Too large to show in full: other response fields are dropped; the data and errors are complete.";
+}
+function _errorsCaption(count) {
+    const row = captionRow("");
+    row.replaceChildren(el("span", "tf:font-medium tf:text-tf-destructive", `${String(count)} ${count === 1 ? "error" : "errors"}`));
+    return row;
+}
+function _errorRows(errors) {
+    const rows = factRows(errors.map((error) => {
+        const record = recordOf(error);
+        const path = Array.isArray(record?.path)
+            ? record.path.map(String).join(".")
+            : "";
+        const message = typeof record?.message === "string" && record.message !== ""
+            ? record.message
+            : prettyPrintParameters(error);
+        return [
+            path === "" ? "—" : path.replaceAll(".", ".\u200b"),
+            message,
+        ];
+    }));
+    rows.dataset.tfGraphqlErrors = String(errors.length);
+    return scrollRegion([rows]);
+}
+function _valuesOf(value) {
+    const record = recordOf(value);
+    const flat = record !== null &&
+        Object.values(record).every((entry) => entry === null || typeof entry !== "object");
+    return flat ? valueRows(value) : valueBlock(value);
+}
+const CUT_MARKER = /… \[truncated: [^\]]*\]$/;
+function _withoutCutMarker(data) {
+    return typeof data === "string" ? data.replace(CUT_MARKER, "…") : data;
+}

package/dist/contract/actions-adapter.d.ts

@@ -39,9 +39,41 @@ export interface ActionIntent {
     query: Record<string, unknown>;
     /**
      * The JSON request body; absent when the action sends none. The cookies and
-     * headers adapters send it with Content-Type application/json.
+     * headers adapters send it with Content-Type application/json. For a
+     * GraphQL action it is the standard GraphQL request, {query, operationName,
+     * variables}.
      */
     body?: unknown;
+    /**
+     * Present when the action is an operation of your app's GraphQL API, so a
+     * request adapter can run it through your own GraphQL client; absent for
+     * every other action.
+     */
+    graphql?: ActionIntentGraphQL;
+}
+/**
+ * The GraphQL operation an action runs, one your app's own code defines. Run it
+ * through your app's GraphQL client. Looking it up by operationName among your
+ * app's own operations sends exactly the request your app sends; parsing
+ * document lets a client print it again, which a persisted-query allowlist may
+ * refuse.
+ */
+export interface ActionIntentGraphQL {
+    /** The operation's name in your app's code, such as "RenamePost". */
+    operationName: string;
+    /** Whether the operation is a "query" or a "mutation". */
+    operationType: "query" | "mutation";
+    /**
+     * The operation's GraphQL document as found in your app's code, with every
+     * fragment it uses; a client that sends parsed documents, such as Apollo
+     * Client, can parse and run it.
+     */
+    document: string;
+    /**
+     * The operation's variables, already validated against the action's
+     * variables schema; empty when it takes none.
+     */
+    variables: Record<string, unknown>;
 }
 /**
  * For APIs authenticated by session cookies. The package fetches baseUrl plus
@@ -88,8 +120,10 @@ export interface RequestActionsAdapter {
     kind: "request";
     /**
      * Performs the request and resolves with your API's response body, which
-     * the agent receives with status 200. Reject (for example by throwing on a
-     * non-2xx response) to report the action as failed.
+     * the agent receives with status 200. For a GraphQL action, resolve the
+     * whole GraphQL response, {data, errors}, even when it carries errors.
+     * Reject (for example by throwing on a non-2xx response) to report the
+     * action as failed.
      */
     execute: (intent: ActionIntent) => Promise<unknown>;
 }
@@ -99,6 +133,10 @@ export interface RequestActionsAdapter {
  * actions and tells the user to do them. The response's status and body (parsed
  * as JSON, otherwise text) go back to the agent; a non-2xx status counts as
  * your API's answer, not a failure, and bodies over about 16,000 characters are
- * truncated.
+ * truncated. A GraphQL response that carries errors keeps all of them unless
+ * the errors alone exceed the limit: its other top-level fields such as
+ * extensions are dropped first, and its data is shortened only if it still does
+ * not fit. A GraphQL response without errors is truncated whole, like any other
+ * body.
  */
 export type ActionsAdapter = CookiesActionsAdapter | HeadersActionsAdapter | RequestActionsAdapter;

package/dist/core/execution-handlers.js

@@ -55,7 +55,7 @@ export function executionHandlersFor(navigate, executeActionIntent, threadId) {
     }
     handlers.set(READ_PAGE_REQUEST_KIND, (entry) => _readPageOutcomeOf(threadId, entry));
     handlers.set(HIGHLIGHT_REQUEST_KIND, (entry) => Promise.resolve(_highlightOutcomeOf(entry)));
-    handlers.set(PREFILL_FORM_REQUEST_KIND, (entry) => Promise.resolve(_prefillFormOutcomeOf(entry)));
+    handlers.set(PREFILL_FORM_REQUEST_KIND, (entry) => _prefillFormOutcomeOf(entry));
     return handlers;
 }
 async function _navigateOutcomeOf(navigate, entry) {
@@ -316,13 +316,13 @@ function _highlightFailedOutcome(error) {
         },
     };
 }
-function _prefillFormOutcomeOf(entry) {
+async function _prefillFormOutcomeOf(entry) {
     const fields = _prefillFieldsOf(entry.action);
     if (fields === null) {
         return UNUSABLE_FIELDS_OUTCOME;
     }
     try {
-        const result = prefilledFieldsReport(fields);
+        const result = await prefilledFieldsReport(fields, browserLayoutProbe());
         return { ok: true, result: { ...result } };
     }
     catch (error) {

package/dist/core/tool-view.js

@@ -1,4 +1,5 @@
 import { actionToolView } from "../components/tool-views/action-view.js";
+import { graphqlActionToolView } from "../components/tool-views/graphql-action-view.js";
 import { commandToolView } from "../components/tool-views/command-view.js";
 import { docsSearchToolView } from "../components/tool-views/docs-search-view.js";
 import { fileEditToolView } from "../components/tool-views/file-edit-view.js";
@@ -10,6 +11,7 @@ export function isReservedToolViewKey(key) {
 export const PACKAGE_TOOL_VIEWS = Object.freeze({
     "teaflask.questions": { version: 1, view: questionsToolView },
     "teaflask.action": { version: 1, view: actionToolView },
+    "teaflask.graphql-action": { version: 1, view: graphqlActionToolView },
     "teaflask.command": { version: 1, view: commandToolView },
     "teaflask.file-edit": { version: 1, view: fileEditToolView },
     "teaflask.docs-search": { version: 1, view: docsSearchToolView },

package/dist/generated/models/apiErrorCode.d.ts

@@ -90,6 +90,9 @@ export declare const ApiErrorCode: {
     readonly ORG_ACTION_PROPOSAL_CHANGED: "ORG_ACTION_PROPOSAL_CHANGED";
     readonly ORG_ACTION_PROPOSAL_NOT_EDITABLE: "ORG_ACTION_PROPOSAL_NOT_EDITABLE";
     readonly ORG_ACTION_SCAN_ALREADY_RUNNING: "ORG_ACTION_SCAN_ALREADY_RUNNING";
+    readonly ORG_ACTION_SPEC_UPLOADS_NOT_AVAILABLE: "ORG_ACTION_SPEC_UPLOADS_NOT_AVAILABLE";
+    readonly ORG_ACTION_SPEC_UPLOAD_INVALID: "ORG_ACTION_SPEC_UPLOAD_INVALID";
+    readonly ORG_ACTION_SPEC_UPLOAD_TOO_LARGE: "ORG_ACTION_SPEC_UPLOAD_TOO_LARGE";
     readonly ORG_SITEMAP_PAGE_INVALID: "ORG_SITEMAP_PAGE_INVALID";
     readonly ORG_SITEMAP_ROUTE_ALREADY_REGISTERED: "ORG_SITEMAP_ROUTE_ALREADY_REGISTERED";
     readonly ORG_SITEMAP_PAGE_ALREADY_ARCHIVED: "ORG_SITEMAP_PAGE_ALREADY_ARCHIVED";
@@ -141,6 +144,12 @@ export declare const ApiErrorCode: {
     readonly SSO_REQUIRED_FOR_DOMAIN: "SSO_REQUIRED_FOR_DOMAIN";
     readonly SSO_CONNECTION_NOT_ACTIVE: "SSO_CONNECTION_NOT_ACTIVE";
     readonly EDGE_ORIGIN_REQUIRED: "EDGE_ORIGIN_REQUIRED";
+    readonly MCP_CONNECTIONS_NOT_AVAILABLE: "MCP_CONNECTIONS_NOT_AVAILABLE";
+    readonly MCP_AUTHORIZATION_EXPIRED: "MCP_AUTHORIZATION_EXPIRED";
+    readonly MCP_CAPABILITY_ABOVE_ROLE: "MCP_CAPABILITY_ABOVE_ROLE";
+    readonly MCP_CAPABILITIES_INVALID: "MCP_CAPABILITIES_INVALID";
+    readonly MCP_AUTHORIZATION_SERVER_UNAVAILABLE: "MCP_AUTHORIZATION_SERVER_UNAVAILABLE";
+    readonly MCP_CONNECTION_CONFLICT: "MCP_CONNECTION_CONFLICT";
     readonly DEMO_ERROR: "DEMO_ERROR";
     readonly HTTP_ERROR: "HTTP_ERROR";
     readonly INTERNAL_ERROR: "INTERNAL_ERROR";

package/dist/generated/models/apiErrorCode.js

@@ -89,6 +89,9 @@ export const ApiErrorCode = {
     ORG_ACTION_PROPOSAL_CHANGED: "ORG_ACTION_PROPOSAL_CHANGED",
     ORG_ACTION_PROPOSAL_NOT_EDITABLE: "ORG_ACTION_PROPOSAL_NOT_EDITABLE",
     ORG_ACTION_SCAN_ALREADY_RUNNING: "ORG_ACTION_SCAN_ALREADY_RUNNING",
+    ORG_ACTION_SPEC_UPLOADS_NOT_AVAILABLE: "ORG_ACTION_SPEC_UPLOADS_NOT_AVAILABLE",
+    ORG_ACTION_SPEC_UPLOAD_INVALID: "ORG_ACTION_SPEC_UPLOAD_INVALID",
+    ORG_ACTION_SPEC_UPLOAD_TOO_LARGE: "ORG_ACTION_SPEC_UPLOAD_TOO_LARGE",
     ORG_SITEMAP_PAGE_INVALID: "ORG_SITEMAP_PAGE_INVALID",
     ORG_SITEMAP_ROUTE_ALREADY_REGISTERED: "ORG_SITEMAP_ROUTE_ALREADY_REGISTERED",
     ORG_SITEMAP_PAGE_ALREADY_ARCHIVED: "ORG_SITEMAP_PAGE_ALREADY_ARCHIVED",
@@ -140,6 +143,12 @@ export const ApiErrorCode = {
     SSO_REQUIRED_FOR_DOMAIN: "SSO_REQUIRED_FOR_DOMAIN",
     SSO_CONNECTION_NOT_ACTIVE: "SSO_CONNECTION_NOT_ACTIVE",
     EDGE_ORIGIN_REQUIRED: "EDGE_ORIGIN_REQUIRED",
+    MCP_CONNECTIONS_NOT_AVAILABLE: "MCP_CONNECTIONS_NOT_AVAILABLE",
+    MCP_AUTHORIZATION_EXPIRED: "MCP_AUTHORIZATION_EXPIRED",
+    MCP_CAPABILITY_ABOVE_ROLE: "MCP_CAPABILITY_ABOVE_ROLE",
+    MCP_CAPABILITIES_INVALID: "MCP_CAPABILITIES_INVALID",
+    MCP_AUTHORIZATION_SERVER_UNAVAILABLE: "MCP_AUTHORIZATION_SERVER_UNAVAILABLE",
+    MCP_CONNECTION_CONFLICT: "MCP_CONNECTION_CONFLICT",
     DEMO_ERROR: "DEMO_ERROR",
     HTTP_ERROR: "HTTP_ERROR",
     INTERNAL_ERROR: "INTERNAL_ERROR",

package/dist/headless.d.ts

@@ -1,6 +1,6 @@
 export { TeaflaskAssistantProvider, type TeaflaskAssistantAnonymousProps, type TeaflaskAssistantIdentityProps, type TeaflaskAssistantProviderBaseProps, type TeaflaskAssistantProviderProps, } from "./components/teaflask-assistant-provider.js";
 export type { AssistantTheme, AssistantThemeDarkTokens, AssistantThemeMode, AssistantThemeTokens, } from "./appearance/theme.js";
-export type { ActionsAdapter, ActionIntent, ActionIntentAction, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
+export type { ActionsAdapter, ActionIntent, ActionIntentAction, ActionIntentGraphQL, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
 export type { ApprovalSubmitTelemetryEvent, AssistantTelemetryEvent, StreamFailedTelemetryEvent, } from "./contract/telemetry.js";
 export type { AssistantSuggestion, AssistantSuggestionInput, AssistantSuggestionKind, } from "./components/conversation-view.js";
 export type { IconAdapter, JsonSchema, ToolViewAdapter, ToolViewCall, ToolViewInstance, ToolViewProps, ToolViewRegistration, ToolViewRegistry, } from "./core/tool-view.js";

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { AssistantActivityResult, AssistantActivitySnapshot, } from "./core
 export type { PendingDecisionGap } from "./core/pending-decision-gap.js";
 export { resetAssistant } from "./persistence/stored-thread.js";
 export { ServingApiError } from "./transport/serving-error.js";
-export type { ActionIntent, ActionIntentAction, ActionsAdapter, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
+export type { ActionIntent, ActionIntentAction, ActionIntentGraphQL, ActionsAdapter, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
 export type { ServingErrorCode, ServingErrorCodeOnTheWire, } from "./contract/errors.js";
 export { ASSISTANT_MESSAGE_MAX_CHARS, type ServingAssistantThread, type TurnStatus, } from "./contract/threads.js";
 export { activeFoldElapsedOf, settledFoldDurationOf, type BlockTiming, type SegmentDuration, } from "./core/segment-timing.js";