@uipath/maestro-builder-sdk 6.58.1 → 6.59.1

package/dist/core/refusals.js

@@ -188,6 +188,9 @@ export const REFUSALS = {
     FORM_TRIGGER_NO_INPUTS: 'lint',
     FUNCTION_EMPTY_RETURNS: 'lint',
     FUNCTION_KEY_NOT_KEY: 'lint',
+    FUNCTION_LOCAL_HAS_FOLDER: 'lint',
+    FUNCTION_LOCAL_NO_PROJECT_ID: 'lint',
+    FUNCTION_LOCAL_PROJECT_ID_NOT_GUID: 'lint',
     FUNCTION_NAME_IS_PATH: 'lint',
     FUNCTION_NO_FOLDER: 'lint',
     FUNCTION_NO_KEY: 'lint',
@@ -203,7 +206,12 @@ export const REFUSALS = {
     GUARDRAIL_NO_VALIDATOR: 'lint',
     GUARDRAIL_TYPE_UNKNOWN: 'lint',
     HITL_APP_INCOMPLETE: 'lint',
+    HITL_APP_INPUT_REQUIRED: 'lint',
+    HITL_APP_INPUT_UNKNOWN: 'lint',
     HITL_APP_MISSING: 'lint',
+    HITL_APP_NO_SCHEMA: 'lint',
+    HITL_APP_OUTCOME_UNKNOWN: 'lint',
+    HITL_APP_SCHEMA_INVALID: 'lint',
     HITL_APP_WITHOUT_VARIANT: 'lint',
     HITL_APP_WITH_FIELDS: 'lint',
     HITL_CHANNEL_UNKNOWN: 'lint',

package/dist/nodes/agent/flow/resources.d.ts

@@ -174,15 +174,6 @@ export declare function httpRequestToolResourceJson(label: string, inputs: Recor
     id: string;
     canvasNodeId: string;
 }): Record<string, unknown>;
-/**
- * The .NET type an Action Center app argument of each field type carries. Studio
- * Web serializes the task payload through `inputSchemaDotnetTypeMapping`, which
- * the platform schema REQUIRES on an `actionCenter` channel; it reads the raw
- * type off the app's action schema, which the SDK does not fetch, so this is
- * the inverse of flow-workbench's `dotNetTypeToJsonSchema` for the scalars and
- * `System.Object` for the two composite types it has no single answer for.
- */
-export declare const DOTNET_TYPE: Record<string, string>;
 /**
  * The folder an app escalation names: the author's `folderPath`, or
  * `solution_folder` when they gave none — an app that ships in this solution.

package/dist/nodes/agent/flow/resources.js

@@ -10,6 +10,7 @@ import ixpDefinition from '../../../core/ixp-definition.json' with { type: 'json
 import { JOB_ATTACHMENT_REF, jobAttachmentDefinition } from '../../../core/agent-sidecar.js';
 import { BUILTIN_TOOL_TYPE, CONNECTOR_TOOL_RESOURCE_TYPE, HTTP_REQUEST_TOOL_TYPE, INTERNAL_TOOL_RESOURCE_TYPE, TOOL_RESOURCE_TYPE, } from '../../../core/agent-tool-resources.js';
 import { buildConfiguration } from '../../../core/connector-configuration.js';
+import { ESCALATION_DOTNET_TYPE } from '../../../core/dotnet-types.js';
 import { multipartBodyFieldName, transportHttpMethod } from '../../../core/connector-inputs.js';
 import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexType } from '../../../core/context-index.js';
 import { formFieldJsonSchema } from '../../../core/form-field-type.js';
@@ -445,18 +446,6 @@ export function httpRequestToolResourceJson(label, inputs, spec) {
         properties: { toolType: HTTP_REQUEST_TOOL_TYPE },
     };
 }
-/**
- * The .NET type an Action Center app argument of each field type carries. Studio
- * Web serializes the task payload through `inputSchemaDotnetTypeMapping`, which
- * the platform schema REQUIRES on an `actionCenter` channel; it reads the raw
- * type off the app's action schema, which the SDK does not fetch, so this is
- * the inverse of flow-workbench's `dotNetTypeToJsonSchema` for the scalars and
- * `System.Object` for the two composite types it has no single answer for.
- */
-export const DOTNET_TYPE = {
-    string: 'System.String', number: 'System.Double', integer: 'System.Int32',
-    boolean: 'System.Boolean', object: 'System.Object', array: 'System.Object',
-};
 /**
  * The folder an app escalation names: the author's `folderPath`, or
  * `solution_folder` when they gave none — an app that ships in this solution.
@@ -537,7 +526,7 @@ export function escalationResourceJson(esc, spec) {
     }
     else {
         const app = esc.app;
-        const mapping = (fields) => Object.fromEntries(Object.entries(fields ?? {}).map(([k, t]) => [k, ownEntry(DOTNET_TYPE, t) ?? 'System.Object']));
+        const mapping = (fields) => Object.fromEntries(Object.entries(fields ?? {}).map(([k, t]) => [k, ownEntry(ESCALATION_DOTNET_TYPE, t) ?? 'System.Object']));
         channel = {
             ...common,
             type: 'actionCenter',

package/dist/nodes/hitl/flow/action-schema.d.ts

@@ -0,0 +1,63 @@
+import type { ActionSchema, AppRef } from './spec.js';
+/** One argument of the schema, in JSON Schema terms. */
+export interface ActionSchemaArg {
+    name: string;
+    schema: Record<string, unknown>;
+    required: boolean;
+}
+/** The schema, whichever spelling it came in. */
+export interface NormalizedActionSchema {
+    inputs: ActionSchemaArg[];
+    outputs: ActionSchemaArg[];
+    inOuts: ActionSchemaArg[];
+    outcomes: string[];
+}
+/**
+ * The schema as one shape, or a sentence saying what is wrong with it. Two
+ * spellings are accepted, both verbatim:
+ *
+ *  - a coded action app's `action-schema.json` — each section a JSON-Schema-ish
+ *    `{ type: 'object', properties: { <name>: { type, required? } } }`;
+ *  - the platform's action schema — each section an array of
+ *    `{ name, type: 'System.String', required, isList }` (the resource file's
+ *    `spec.actionSchema`, and what the Apps API returns).
+ */
+export declare function normalizeActionSchema(schema: unknown): NormalizedActionSchema | string;
+/**
+ * `inputs.app.inputSchema`: the inputs and the inOuts, with the required ones
+ * listed — `createInputSchemaFromAppSchema`'s shape, key for key.
+ */
+export declare function appInputSchema(s: NormalizedActionSchema): Record<string, unknown>;
+/** What the reviewer answers: the outputs and the inOuts, by name. */
+export declare function appAnswerSchemas(s: NormalizedActionSchema): Array<[string, Record<string, unknown>]>;
+/**
+ * What a `check` rule needs of an app's contract — the input names, the
+ * required ones, the answers and the buttons — from whichever of `actionSchema`
+ * and a verbatim `inputSchema` the app carries; `undefined` with neither, a
+ * sentence when one is malformed.
+ */
+export declare function appContract(app: AppRef | undefined): {
+    inputs: string[];
+    required: string[];
+    answers: string[];
+    outcomes: string[];
+} | string | undefined;
+/**
+ * The schema back from a node, as decompile prints it:
+ *
+ *  - `{ actionSchema }`, in the `action-schema.json` spelling, when one
+ *    reproduces the node's `inputSchema` and typed answer BYTE FOR BYTE — what
+ *    the SDK and Studio Web's picker write. A property in both the input schema
+ *    and the answer is an inOut; the rest split by side; outcomes are the task's.
+ *  - `{ inputSchema }`, verbatim, otherwise — a hand-edited schema (a `title`, a
+ *    nested object's `properties`) that no action schema lowers to. Recompiling
+ *    writes it back unchanged.
+ *
+ * Either way serialize writes the node's `inputSchema` back as it was: the lift
+ * is checked against the emission, not assumed to invert it.
+ */
+export declare function liftActionSchema(inputSchema: unknown, answers: Record<string, unknown> | undefined, outcomes: string[]): {
+    actionSchema: ActionSchema;
+} | {
+    inputSchema: Record<string, unknown>;
+} | undefined;

package/dist/nodes/hitl/flow/action-schema.js

@@ -0,0 +1,228 @@
+/**
+ * An Action App's action schema — the contract of its form: what the task sends
+ * it (`inputs`), what the reviewer answers (`outputs`), what goes both ways
+ * (`inOuts`) and which buttons complete it (`outcomes`) — read in either of the
+ * two spellings an author can hold, and lowered to what the node carries.
+ *
+ * Why the node needs it: flow-v1's serializer types the task's
+ * `HitlTaskArguments` from `inputs.app.inputSchema`, and with none it falls back
+ * to `{ type: 'string' }` for every bound input (`hitl-serialization.ts`, the
+ * `appInputBindings` fallback). A number or an integer then reaches the app as a
+ * string. Studio Web's app picker writes the schema from the app's action schema
+ * (`HITLAppPicker.tsx` → `createInputSchemaFromAppSchema`); this SDK is offline,
+ * so the author hands it the same schema.
+ *
+ * The emission is the PRODUCT's, not a reading of JSON Schema: the platform
+ * spelling goes through the picker's own `.NET → JSON` table, and the
+ * `action-schema.json` spelling first through `uip codedapp push`'s `JSON → .NET`
+ * table — the path the same app's schema takes to reach the picker — so one app
+ * written either way emits the same bytes (core/dotnet-types.ts). That path
+ * keeps only a type: an object input's nested `properties`, a `description`, a
+ * `title` do not survive it, and do not survive here.
+ */
+import { actionSchemaFileDotNetType, dotNetTypeToJsonSchema } from '../../../core/dotnet-types.js';
+const FILE_TYPES = 'string, integer, number, boolean, object, file, ContentValidationData or array';
+/** An `action-schema.json` property's JSON Schema, or what is wrong with it. */
+function fileSchema(where, p) {
+    const isList = p.type === 'array';
+    const item = (isList ? p.items : p);
+    if (isList && (!item || typeof item !== 'object'))
+        return `"${where}" is an array with no items schema`;
+    if (item.type === 'array')
+        return `"${where}" is an array of arrays, which uip codedapp push refuses`;
+    const dotNet = actionSchemaFileDotNetType(item.type, item.format);
+    if (dotNet === undefined) {
+        return `"${where}" has the type ${JSON.stringify(item.type)}; an action-schema.json type is one of ${FILE_TYPES}`;
+    }
+    return dotNetTypeToJsonSchema(dotNet, isList);
+}
+/**
+ * The schema as one shape, or a sentence saying what is wrong with it. Two
+ * spellings are accepted, both verbatim:
+ *
+ *  - a coded action app's `action-schema.json` — each section a JSON-Schema-ish
+ *    `{ type: 'object', properties: { <name>: { type, required? } } }`;
+ *  - the platform's action schema — each section an array of
+ *    `{ name, type: 'System.String', required, isList }` (the resource file's
+ *    `spec.actionSchema`, and what the Apps API returns).
+ */
+export function normalizeActionSchema(schema) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema))
+        return 'it is not an object';
+    const s = schema;
+    const section = (key) => {
+        const v = s[key];
+        if (v === undefined || v === null)
+            return [];
+        if (Array.isArray(v)) {
+            const args = [];
+            for (const a of v) {
+                if (!a || typeof a.name !== 'string' || a.name === '' || typeof a.type !== 'string') {
+                    return `"${key}" has an entry without a name and a type`;
+                }
+                args.push({ name: a.name, schema: dotNetTypeToJsonSchema(a.type, a.isList === true), required: a.required === true });
+            }
+            return args;
+        }
+        if (typeof v !== 'object')
+            return `"${key}" is neither an array nor an object`;
+        const props = v.properties ?? {};
+        if (!props || typeof props !== 'object' || Array.isArray(props))
+            return `"${key}.properties" is not an object`;
+        const args = [];
+        for (const [name, p] of Object.entries(props)) {
+            if (!p || typeof p !== 'object' || typeof p.type !== 'string')
+                return `"${key}.properties.${name}" has no type`;
+            // Outcomes are buttons: push flattens them to System.String whatever they say.
+            const schema = key === 'outcomes' ? { type: 'string' } : fileSchema(`${key}.properties.${name}`, p);
+            if (typeof schema === 'string')
+                return schema;
+            args.push({ name, schema, required: p.required === true });
+        }
+        return args;
+    };
+    const inputs = section('inputs');
+    const outputs = section('outputs');
+    const inOuts = section('inOuts');
+    const outcomes = section('outcomes');
+    for (const r of [inputs, outputs, inOuts, outcomes])
+        if (typeof r === 'string')
+            return r;
+    return {
+        inputs: inputs,
+        outputs: outputs,
+        inOuts: inOuts,
+        outcomes: outcomes.map((o) => o.name),
+    };
+}
+/**
+ * `inputs.app.inputSchema`: the inputs and the inOuts, with the required ones
+ * listed — `createInputSchemaFromAppSchema`'s shape, key for key.
+ */
+export function appInputSchema(s) {
+    const all = [...s.inputs, ...s.inOuts];
+    const required = all.filter((a) => a.required).map((a) => a.name);
+    return {
+        type: 'object',
+        properties: Object.fromEntries(all.map((a) => [a.name, { ...a.schema }])),
+        ...(required.length > 0 ? { required } : {}),
+    };
+}
+/** What the reviewer answers: the outputs and the inOuts, by name. */
+export function appAnswerSchemas(s) {
+    return [...s.outputs, ...s.inOuts].map((a) => [a.name, { ...a.schema }]);
+}
+/**
+ * What a `check` rule needs of an app's contract — the input names, the
+ * required ones, the answers and the buttons — from whichever of `actionSchema`
+ * and a verbatim `inputSchema` the app carries; `undefined` with neither, a
+ * sentence when one is malformed.
+ */
+export function appContract(app) {
+    if (app?.actionSchema !== undefined && app?.inputSchema !== undefined) {
+        return 'it gives both actionSchema and inputSchema; inputSchema is the node\'s verbatim form, for a decompiled flow, so keep one';
+    }
+    if (app?.actionSchema !== undefined) {
+        const s = normalizeActionSchema(app.actionSchema);
+        if (typeof s === 'string')
+            return s;
+        const all = [...s.inputs, ...s.inOuts];
+        return {
+            inputs: all.map((a) => a.name),
+            required: all.filter((a) => a.required).map((a) => a.name),
+            answers: [...s.outputs, ...s.inOuts].map((a) => a.name),
+            outcomes: s.outcomes,
+        };
+    }
+    if (app?.inputSchema !== undefined) {
+        const i = app.inputSchema;
+        if (!i || typeof i !== 'object' || !i.properties || typeof i.properties !== 'object' || Array.isArray(i.properties)) {
+            return 'its inputSchema has no properties object';
+        }
+        return {
+            inputs: Object.keys(i.properties),
+            required: Array.isArray(i.required) ? i.required.filter((r) => typeof r === 'string') : [],
+            answers: [],
+            outcomes: [],
+        };
+    }
+    return undefined;
+}
+/** The `action-schema.json` property a picker-shaped JSON Schema came from, if any. */
+function fileProperty(p) {
+    if (!p || typeof p !== 'object' || Array.isArray(p))
+        return undefined;
+    const { type, format, items, ...rest } = p;
+    if (Object.keys(rest).length > 0)
+        return undefined;
+    if (type === 'array') {
+        const item = fileProperty(items);
+        return item !== undefined && format === undefined ? { type: 'array', items: item } : undefined;
+    }
+    if (items !== undefined)
+        return undefined;
+    if (type === 'string' && format === 'date-time')
+        return { type: 'string', format: 'date' };
+    if (format !== undefined)
+        return undefined;
+    const byType = {
+        string: 'string', integer: 'integer', number: 'number', boolean: 'boolean',
+        'System.Object': 'object',
+        'UiPath.Platform.ResourceHandling.IResource': 'file',
+        'UiPath.DocumentProcessing.Contracts.Actions.ContentValidationData': 'ContentValidationData',
+    };
+    return typeof type === 'string' && Object.hasOwn(byType, type) ? { type: byType[type] } : undefined;
+}
+/**
+ * The schema back from a node, as decompile prints it:
+ *
+ *  - `{ actionSchema }`, in the `action-schema.json` spelling, when one
+ *    reproduces the node's `inputSchema` and typed answer BYTE FOR BYTE — what
+ *    the SDK and Studio Web's picker write. A property in both the input schema
+ *    and the answer is an inOut; the rest split by side; outcomes are the task's.
+ *  - `{ inputSchema }`, verbatim, otherwise — a hand-edited schema (a `title`, a
+ *    nested object's `properties`) that no action schema lowers to. Recompiling
+ *    writes it back unchanged.
+ *
+ * Either way serialize writes the node's `inputSchema` back as it was: the lift
+ * is checked against the emission, not assumed to invert it.
+ */
+export function liftActionSchema(inputSchema, answers, outcomes) {
+    if (!inputSchema || typeof inputSchema !== 'object' || Array.isArray(inputSchema))
+        return undefined;
+    const verbatim = { inputSchema: JSON.parse(JSON.stringify(inputSchema)) };
+    const props = (inputSchema.properties ?? {});
+    const required = new Set(Array.isArray(inputSchema.required)
+        ? inputSchema.required.filter((r) => typeof r === 'string') : []);
+    const answerProps = Object.fromEntries(Object.entries(answers ?? {}).filter(([k]) => k !== 'Action'));
+    const lift = (entries, req) => {
+        const out = [];
+        for (const [k, p] of entries) {
+            const f = fileProperty(p);
+            if (f === undefined)
+                return undefined;
+            out.push([k, { ...f, ...(req(k) ? { required: true } : {}) }]);
+        }
+        return { type: 'object', properties: Object.fromEntries(out) };
+    };
+    const ins = lift(Object.entries(props).filter(([k]) => !(k in answerProps)), (k) => required.has(k));
+    const ios = lift(Object.entries(props).filter(([k]) => k in answerProps), (k) => required.has(k));
+    const outs = lift(Object.entries(answerProps).filter(([k]) => !(k in props)), () => false);
+    if (!ins || !ios || !outs)
+        return verbatim;
+    const actionSchema = {
+        inputs: ins,
+        ...(Object.keys(outs.properties).length > 0 ? { outputs: outs } : {}),
+        ...(Object.keys(ios.properties).length > 0 ? { inOuts: ios } : {}),
+        ...(outcomes.length > 0
+            ? { outcomes: { type: 'object', properties: Object.fromEntries(outcomes.map((o) => [o, { type: 'string' }])) } }
+            : {}),
+    };
+    // Only a lift that serializes back to the same bytes is an action schema.
+    const again = normalizeActionSchema(actionSchema);
+    if (typeof again === 'string')
+        return verbatim;
+    const same = JSON.stringify(appInputSchema(again)) === JSON.stringify(inputSchema)
+        && JSON.stringify(Object.fromEntries(appAnswerSchemas(again))) === JSON.stringify(answerProps);
+    return same ? { actionSchema } : verbatim;
+}

package/dist/nodes/hitl/flow/check.js

@@ -3,6 +3,7 @@ import { nearestName } from '../../../core/edit-distance.js';
 import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, outcomeIdOf } from '../../../core/hitl-routing.js';
+import { appContract } from './action-schema.js';
 export const HITL_DIAGNOSTICS = {
     HITL_VARIANT_UNKNOWN: { severity: 'error', summary: 'a variant that names no human-task node type' },
     HITL_OUTCOME_PORTS_VARIANT: { severity: 'error', summary: 'exposeError or outcomePorts on a variant that cannot honour it' },
@@ -19,6 +20,11 @@ export const HITL_DIAGNOSTICS = {
     HITL_APP_WITH_FIELDS: { severity: 'error', summary: 'form fields on an app-backed task' },
     HITL_APP_MISSING: { severity: 'error', summary: 'an action-app task that names no app' },
     HITL_APP_INCOMPLETE: { severity: 'error', summary: 'an app reference missing name, key or folderPath' },
+    HITL_APP_SCHEMA_INVALID: { severity: 'error', summary: 'an app actionSchema that is not an action schema' },
+    HITL_APP_NO_SCHEMA: { severity: 'warning', summary: 'inputs sent to an app with no actionSchema, so every one is a string' },
+    HITL_APP_INPUT_UNKNOWN: { severity: 'error', summary: 'an app input the action schema does not declare' },
+    HITL_APP_INPUT_REQUIRED: { severity: 'error', summary: 'a required app input left unbound' },
+    HITL_APP_OUTCOME_UNKNOWN: { severity: 'error', summary: 'an outcome the app has no button for' },
     HITL_NO_FIELDS: { severity: 'error', summary: 'no fields array' },
     HITL_FIELD_NO_ID: { severity: 'error', summary: 'a form field with no id' },
     HITL_DUP_FIELD: { severity: 'error', summary: 'a form field id declared twice' },
@@ -183,6 +189,48 @@ export function checkHitl(inputs, ctx) {
                 return;
             }
         }
+        // The app's action schema: what types its inputs, and what it answers.
+        const bound = Object.keys(app.inputs ?? {});
+        const contract = appContract(app);
+        if (contract === undefined) {
+            if (bound.length > 0) {
+                at('HITL_APP_NO_SCHEMA', `Human task "${step}" sends ${bound.length} input(s) to its Action App but gives no actionSchema. `
+                    + `The platform types the task's arguments from the app's schema and falls back to string for every `
+                    + `input without one, so a number or a boolean reaches the app as text — and its answer fields `
+                    + `cannot be read with out('${step}', …).`, `app: { …, actionSchema: <the app's action-schema.json> }`);
+            }
+        }
+        else if (typeof contract === 'string') {
+            at('HITL_APP_SCHEMA_INVALID', `Human task "${step}" gives its Action App a schema that is not usable: ${contract}. `
+                + `Pass the app's action-schema.json verbatim, or the platform's action schema (its `
+                + `inputs/outputs/inOuts/outcomes arrays).`);
+            return;
+        }
+        else {
+            const names = contract.inputs;
+            for (const k of bound) {
+                if (!names.includes(k)) {
+                    const nearest = nearestName(k, names);
+                    at('HITL_APP_INPUT_UNKNOWN', `Human task "${step}" sends "${k}" to its Action App, which declares no such input `
+                        + `(it takes ${names.length > 0 ? names.join(', ') : 'none'}). The value is dropped.`, nearest !== undefined ? `inputs: { ${JSON.stringify(nearest)}: … }` : undefined);
+                }
+            }
+            const missing = contract.required.filter((r) => !bound.includes(r));
+            if (missing.length > 0) {
+                at('HITL_APP_INPUT_REQUIRED', `Human task "${step}" leaves the Action App's required input(s) ${missing.join(', ')} unbound, `
+                    + `so the task's arguments fail the app's own schema.`, `inputs: { ${missing.map((m) => `${JSON.stringify(m)}: …`).join(', ')} }`);
+            }
+            if (contract.outcomes.length > 0) {
+                for (const o of Array.isArray(inputs?.outcomes) ? inputs.outcomes : []) {
+                    const name = typeof o === 'string' ? o : o?.name;
+                    if (typeof name === 'string' && name !== '' && !contract.outcomes.includes(name)) {
+                        const nearest = nearestName(name, contract.outcomes);
+                        at('HITL_APP_OUTCOME_UNKNOWN', `Human task "${step}" routes on the outcome "${name}", but its Action App completes only with `
+                            + `${contract.outcomes.join(', ')}. The reviewer can never pick it.`, nearest !== undefined ? `'${nearest}'` : undefined);
+                    }
+                }
+            }
+        }
         // Outcomes still matter for an app task: the flow's own routing and its
         // `Action`/`status` outputs are derived from them, so fall through to the
         // outcome rules below rather than returning here.
@@ -389,11 +437,23 @@ export function checkHitlRead({ node: name, field, rest, reader: step }, form, r
         return; // `$vars.<name>.output` — the whole object, fine.
     if (answer === 'Action')
         return; // which outcome was pressed.
-    const answers = (form?.fields ?? [])
-        .filter((f) => isAnswerField(f) && typeof f?.id === 'string')
-        .map((f) => f.id);
+    const appSchema = form?.variant === 'action-app' && form.app?.actionSchema !== undefined
+        ? appContract({ ...form.app, inputSchema: undefined }) : undefined;
+    const appAnswers = typeof appSchema === 'object' ? appSchema.answers : [];
+    const answers = [
+        ...(form?.fields ?? []).filter((f) => isAnswerField(f) && typeof f?.id === 'string').map((f) => f.id),
+        ...appAnswers,
+    ];
     if (answers.includes(answer))
         return;
+    if (form?.variant === 'action-app') {
+        const nearestApp = nearestName(answer, [...answers, 'Action']);
+        report('HITL_READ_UNKNOWN_FIELD', `Human task "${name}" has no answer "${answer}" (read as "$vars.${name}.output.${answer}" in `
+            + `"${step}"). Its Action App answers with ${appSchema === undefined
+                ? 'fields only its actionSchema declares, and it gives none'
+                : `its schema's outputs and inOuts (${appAnswers.length > 0 ? appAnswers.join(', ') : 'none'})`} plus "Action".`, nearestApp !== undefined ? `out('${name}', '${nearestApp}')` : `app: { …, actionSchema: <the app's action-schema.json> }`);
+        return;
+    }
     const shown = (form?.fields ?? [])
         .filter((f) => f?.direction === 'input' && typeof f?.id === 'string')
         .map((f) => f.id);

package/dist/nodes/hitl/flow/node-type.js

@@ -19,6 +19,7 @@ import { OUTCOME_HANDLE_NODE_TYPES, hitlExitModel, outcomeIdOf, outcomeSlug } fr
 import { jsonClone } from '../../../core/json-clone.js';
 import { schemaId } from '../../../core/stable-id.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
+import { appAnswerSchemas, appInputSchema, liftActionSchema, normalizeActionSchema } from './action-schema.js';
 import { checkHitl, checkHitlRead } from './check.js';
 import { CompileRefusal } from '../../../core/compile-refusal.js';
 const BASE = 'uipath.human-in-the-loop';
@@ -107,6 +108,15 @@ function hitlInputs(inputs, nodeType, ctx) {
             continue;
         properties[f.id] = { ...formFieldJsonSchema(f.type) };
     }
+    // An app's answer is its action schema's outputs and inOuts — the app owns the
+    // form, so the schema is the only place they are declared.
+    const appSchema = isApp && inputs?.app?.actionSchema !== undefined
+        ? normalizeActionSchema(inputs.app.actionSchema) : undefined;
+    const schema = typeof appSchema === 'object' ? appSchema : undefined;
+    if (schema !== undefined) {
+        for (const [name, s] of appAnswerSchemas(schema))
+            properties[name] = s;
+    }
     const names = outcomes.map((o) => o.name).filter((n) => typeof n === 'string');
     if (names.length > 0) {
         properties.Action = { type: 'string', enum: names, default: names[0] };
@@ -187,6 +197,10 @@ function hitlInputs(inputs, nodeType, ctx) {
                         key: app.key,
                         folderPath: app.folderPath,
                         ...(app.appSystemName !== undefined ? { appSystemName: app.appSystemName } : {}),
+                        // What types the task's arguments (see action-schema.ts): lowered
+                        // from the action schema, or the decompiled node's own, verbatim.
+                        ...(schema !== undefined ? { inputSchema: appInputSchema(schema) }
+                            : isApp && app.inputSchema !== undefined ? { inputSchema: jsonClone(app.inputSchema) } : {}),
                     },
                     ...(Object.keys(appInputBindings).length > 0 ? { appInputBindings } : {}),
                 }
@@ -406,6 +420,12 @@ function liftHitl(node, typeName, ctx) {
         ...(app.appSystemName === null ? { appSystemName: null }
             : typeof app.appSystemName === 'string' ? { appSystemName: app.appSystemName } : {}),
         ...(appInputs !== undefined ? { inputs: appInputs } : {}),
+        // The schema comes back as an action schema when one serializes to the
+        // node's exact bytes, else as the node's inputSchema verbatim — either way a
+        // recompile writes the same input schema (action-schema.ts).
+        ...(variant === 'action-app' && app.inputSchema !== undefined
+            ? liftActionSchema(app.inputSchema, n.outputs?.output?.properties, outcomes.map((o) => (typeof o === 'string' ? o : o.name)))
+            : {}),
     };
     // The validation station's own inputs ride as PLAIN `$vars.…` paths. Anything
     // but a `$vars.` reference stays the wire text verbatim.
@@ -502,6 +522,8 @@ function printHitl({ inputs }, ctx) {
                 : h.app.appSystemName !== undefined ? ctx.string(h.app.appSystemName) : undefined],
         ['inputs', h.app.inputs !== undefined
                 ? obj(Object.entries(h.app.inputs).map(([k, v]) => [k, val(v)]), ctx) : undefined],
+        ['actionSchema', h.app.actionSchema !== undefined ? ctx.value(h.app.actionSchema) : undefined],
+        ['inputSchema', h.app.inputSchema !== undefined ? ctx.value(h.app.inputSchema) : undefined],
     ], ctx);
     const document = h.document === undefined ? undefined : obj([
         ['extractionResult', val(h.document.extractionResult)],

package/dist/nodes/hitl/flow/spec.d.ts

@@ -182,7 +182,106 @@ export interface AppRef {
      * into the task's `HitlTaskArguments`.
      */
     inputs?: Record<string, Expr | string>;
+    /**
+     * The app's action schema, verbatim — what types each input, and what the
+     * reviewer answers. For a coded action app that is its `action-schema.json`,
+     * so `import schema from './InvoiceReview/action-schema.json'` and pass it;
+     * the platform's own spelling (the arrays of `{ name, type: 'System.Decimal',
+     * required }` in the solution's `resources/solution_folder/app/codedAction/<app>.json`
+     * `spec.actionSchema`) is accepted too.
+     *
+     * Without it every input reaches the app as a STRING: the platform types the
+     * task's arguments from `inputs.app.inputSchema`, which is written from this,
+     * and falls back to `string` for each bound input when there is none. It also
+     * declares the answer, so `out('<step>', '<output>')` reads are checked.
+     *
+     * @enforcedBy HITL_APP_NO_SCHEMA Inputs sent to an app without its schema all become strings.
+     * @enforcedBy HITL_APP_INPUT_UNKNOWN An input the app does not declare.
+     * @enforcedBy HITL_APP_INPUT_REQUIRED A required app input left unbound.
+     * @enforcedBy HITL_APP_OUTCOME_UNKNOWN An outcome the app has no button for.
+     *
+     * Only each argument's TYPE reaches the node, as Studio Web writes it: an
+     * object input becomes `{ type: 'System.Object' }` and a `file` input
+     * `{ type: 'UiPath.Platform.ResourceHandling.IResource' }` (the platform's .NET
+     * names, passed through by its picker), and a nested object's `properties`, a
+     * `description` or a `title` are not carried.
+     */
+    actionSchema?: ActionSchema;
+    /**
+     * The node's `inputs.app.inputSchema`, verbatim — what decompile writes for a
+     * flow whose schema no {@link AppRef.actionSchema} lowers to (a hand-edited
+     * `title`, a nested object's `properties`), so recompiling leaves it as it
+     * was. Author new flows with `actionSchema`; give one or the other.
+     *
+     * @enforcedBy HITL_APP_SCHEMA_INVALID Both forms, or an inputSchema with no properties.
+     */
+    inputSchema?: Record<string, unknown>;
+}
+/** One property of an `action-schema.json` section. */
+export interface ActionSchemaProperty {
+    /**
+     * Its type: `'string'`, `'integer'`, `'number'`, `'boolean'`, `'object'`,
+     * `'file'`, `'ContentValidationData'`, or `'array'` with `items` — the set
+     * `uip codedapp push` accepts.
+     */
+    type: string;
+    /** Whether the app needs it. A required input must be bound in `app.inputs`. */
+    required?: boolean;
+    /** What it is for. Documentation only: it is not emitted. */
+    description?: string;
+    /** `'date'` (a `System.DateOnly`) or `'uuid'` (a `System.Guid`). */
+    format?: string;
+    /** An array's item schema, e.g. `{ type: 'string' }`. */
+    items?: Record<string, unknown>;
+    /** An object's own properties. The app keeps them; the node does not. */
+    properties?: Record<string, ActionSchemaProperty>;
+}
+/** One section (`inputs`, `outputs`, `inOuts`, `outcomes`) of an `action-schema.json`. */
+export interface ActionSchemaSection {
+    /** Always `'object'`. */
+    type?: 'object';
+    /** The section's arguments, by the app's own names. */
+    properties?: Record<string, ActionSchemaProperty>;
+}
+/** A coded action app's `action-schema.json`. */
+export interface ActionSchemaFile {
+    /** What the task sends the app. Becomes `inputs.app.inputSchema`. */
+    inputs?: ActionSchemaSection;
+    /** What the reviewer answers. Readable as `out('<step>', '<name>')`. */
+    outputs?: ActionSchemaSection;
+    /** Sent to the app AND answered back. */
+    inOuts?: ActionSchemaSection;
+    /** The buttons that complete the task. The flow's `outcomes` must be among them. */
+    outcomes?: ActionSchemaSection;
+}
+/** One argument of the platform's action schema. */
+export interface PlatformActionSchemaArg {
+    /** The argument's name, as the app declares it. */
+    name: string;
+    /** A .NET type name, e.g. `'System.Decimal'`. */
+    type: string;
+    /** Whether the app needs it. */
+    required?: boolean;
+    /** A list of `type`, which lowers to a JSON array. */
+    isList?: boolean;
+    /** The platform's other keys (`key`, `version`, `typeNamespace`, …), ignored. */
+    [field: string]: unknown;
+}
+/** The platform's action schema (Apps API, a solution's `spec.actionSchema`). */
+export interface PlatformActionSchema {
+    /** What the task sends the app. */
+    inputs?: PlatformActionSchemaArg[];
+    /** What the reviewer answers. */
+    outputs?: PlatformActionSchemaArg[];
+    /** Sent and answered back. */
+    inOuts?: PlatformActionSchemaArg[];
+    /** The buttons that complete the task. */
+    outcomes?: PlatformActionSchemaArg[];
+    /** The schema's other keys (`key`, `id`, `name`, …), ignored. */
+    [field: string]: unknown;
 }
+/** An Action App's action schema, in either spelling. */
+export type ActionSchema = ActionSchemaFile | PlatformActionSchema;
 export interface HitlInputs {
     /**
      * Which human-task node type to emit. Omit it for today's default — see