@noodleseed/one 0.174.0 → 0.175.0

package/node_modules/@noodle-borg/compiler/dist/artifact/version.d.ts

@@ -64,7 +64,8 @@
  */
 /** `0.21.0`: protected tools may opt into public descriptor discovery without execution permission. */
 /** `0.22.0`: governed public-page extraction declarations and ordinary generated tools. */
-export declare const ARTIFACT_SCHEMA_VERSION = "0.22.0";
+/** `0.23.0`: bounded `collect` interaction metadata keyed by opener tool (ADR 0240); never MCP-visible. */
+export declare const ARTIFACT_SCHEMA_VERSION = "0.23.0";
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
 //# sourceMappingURL=version.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/artifact/version.js

@@ -64,7 +64,8 @@
  */
 /** `0.21.0`: protected tools may opt into public descriptor discovery without execution permission. */
 /** `0.22.0`: governed public-page extraction declarations and ordinary generated tools. */
-export const ARTIFACT_SCHEMA_VERSION = '0.22.0';
+/** `0.23.0`: bounded `collect` interaction metadata keyed by opener tool (ADR 0240); never MCP-visible. */
+export const ARTIFACT_SCHEMA_VERSION = '0.23.0';
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
 //# sourceMappingURL=version.js.map

package/node_modules/@noodle-borg/compiler/dist/compile.js

@@ -15,6 +15,7 @@ import { parseAmbientContext } from './context-compile.js';
 import { findExternalRef, parseFulfilment } from './fulfilment-structural.js';
 import { compileManagedCollections } from './managed-collections.js';
 import { cspOriginFaults } from './manifest/csp-origins.js';
+import { compileToolInteractions } from './manifest/interaction-validation.js';
 import { parseManifestDocument } from './manifest/parse-document.js';
 import { manifestSchema } from './manifest/schema.js';
 import { resolveSchemaUses } from './manifest/schema-refs.js';
@@ -416,11 +417,14 @@ export function compileManifest(raw, options = {}) {
         toolUiMetaByName,
         errors,
     });
+    const toolInteractions = compileToolInteractions(manifest.tools, artifactTools, errors);
     errors.push(...validateWebsiteProjection(manifest.server.assistant, {
         tools: artifactTools,
         resources: artifactResources,
         prompts: artifactPrompts,
         knowledge,
+        interactions: toolInteractions,
+        connectors: declared,
     }));
     if (errors.length > 0) {
         return { ok: false, errors };
@@ -445,6 +449,7 @@ export function compileManifest(raw, options = {}) {
         ...(knowledge.length > 0 ? { knowledge } : {}),
         ...(managedCollections.length > 0 ? { managedCollections } : {}),
         ...(variables.length > 0 ? { variables } : {}),
+        ...(toolInteractions === undefined ? {} : { toolInteractions }),
     });
     const warnings = [
         ...brandingWarnings(manifest.server.branding),

package/node_modules/@noodle-borg/compiler/dist/errors.d.ts

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_messaging_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_messaging_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'interaction_action_invalid' | 'interaction_field_unknown' | 'interaction_field_control_mismatch' | 'interaction_field_missing' | 'interaction_initial_value_unknown' | 'interaction_consent_invalid' | 'interaction_expiry_invalid' | 'channel_dependency_missing' | 'channel_requirement_unsupported' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/index.d.ts

@@ -3,7 +3,7 @@ export { APP_PACKAGE_V1_VALIDATION_LIMITS, appPackageArtifactV1Schema, canonical
 export { type ParsedUri, type ParseUriResult, parseUriTemplate, type TemplateUri, } from '@noodle-borg/uri-template';
 export { compileAppPackage } from './app-package/compile.js';
 export { isSafeReadTool, requiresToolConfirmation } from './artifact/consent.js';
-export { ARTIFACT_SCHEMA_VERSION, type ArtifactConnectionSource, type ArtifactConnectorBinding, type ArtifactCustomerAuthRouting, type ArtifactFulfilment, type ArtifactManagedCollection, type ArtifactMeta, type ArtifactPackagedAsset, type ArtifactPrompt, type ArtifactPromptArgument, type ArtifactResource, type ArtifactServer, type ArtifactServerContext, type ArtifactState, type ArtifactStateHandle, type ArtifactStateHandleKind, type ArtifactStateHandleScope, type ArtifactStep, type ArtifactTool, type ArtifactToolAuthorization, type ExprMap, type JsonSchema, MCP_APP_MIME_TYPE, type OperationRef, type ResolvedCredentialBinding, type ResolvedOperationRef, type RuntimeArtifact, type UnresolvedOperationRef, type WidgetUiMeta, } from './artifact/types.js';
+export { ARTIFACT_SCHEMA_VERSION, type ArtifactCollectField, type ArtifactCollectInteraction, type ArtifactConnectionSource, type ArtifactConnectorBinding, type ArtifactCustomerAuthRouting, type ArtifactFulfilment, type ArtifactManagedCollection, type ArtifactMeta, type ArtifactPackagedAsset, type ArtifactPrompt, type ArtifactPromptArgument, type ArtifactResource, type ArtifactServer, type ArtifactServerContext, type ArtifactState, type ArtifactStateHandle, type ArtifactStateHandleKind, type ArtifactStateHandleScope, type ArtifactStep, type ArtifactTool, type ArtifactToolAuthorization, type ExprMap, type JsonSchema, MCP_APP_MIME_TYPE, type OperationRef, type ResolvedCredentialBinding, type ResolvedOperationRef, type RuntimeArtifact, type UnresolvedOperationRef, type WidgetUiMeta, } from './artifact/types.js';
 export { assetReference, type HostedAssetOptions, type HostedPackagedAsset, isPackagedAssetReference, type LocalAssetOptions, localAssetRoutePrefix, type PackagedAsset, type PackagedAssetReference, type PreparedPackagedAsset, prepareLocalAssets, } from './assets.js';
 export { type ArtifactVariableDeclaration, compileVariableDeclarations, MAX_VARIABLE_DECLARATIONS, MAX_VARIABLE_SCHEMA_BYTES, MAX_VARIABLE_SCHEMA_DEPTH, MAX_VARIABLE_VALUE_BYTES, type VariableDeclarationManifest, validateVariableDeclaration, variableDeclarationManifestSchema, } from './business-variables.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
@@ -21,7 +21,7 @@ export { type ArrayNode, type CoalesceNode, type CondNode, type ExprNode, type O
 export { isValidName, parseOperationRef } from './manifest/naming.js';
 export { type Manifest, manifestSchema } from './manifest/schema.js';
 export { type ResolveSchemaResult, resolveSchemaUses, type SchemasMap, } from './manifest/schema-refs.js';
-export { anonymousBehavior } from './manifest/website-projection.js';
+export { anonymousBehavior, isNativeRecordsOperation } from './manifest/website-projection.js';
 export { type SniffedImage, sniffImageBytes } from './mime-sniffing.js';
 export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';

package/node_modules/@noodle-borg/compiler/dist/index.js

@@ -18,7 +18,7 @@ export { parseCondition, parseValue, } from './manifest/expression.js';
 export { isValidName, parseOperationRef } from './manifest/naming.js';
 export { manifestSchema } from './manifest/schema.js';
 export { resolveSchemaUses, } from './manifest/schema-refs.js';
-export { anonymousBehavior } from './manifest/website-projection.js';
+export { anonymousBehavior, isNativeRecordsOperation } from './manifest/website-projection.js';
 export { sniffImageBytes } from './mime-sniffing.js';
 export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';

package/node_modules/@noodle-borg/compiler/dist/manifest/interaction-schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+/**
+ * The `collect` interaction block (ADR 0240): bounded metadata on an opener tool describing which
+ * fields a platform renderer collects for one confirmed action, which are private, what is reviewed,
+ * and what to say on success. It carries meaning only: no layout, ordering script or screen language.
+ * Field, action and output references are checked against the declared tools by the compile pass
+ * (`interaction-validation.ts`), which also bounds `confirmationExpiry` so a bad value reports its own
+ * code instead of a shape error.
+ */
+export declare const COLLECT_CONTROLS: readonly ["text", "textarea", "email", "phone", "url", "select", "consent"];
+export type CollectControl = (typeof COLLECT_CONTROLS)[number];
+export declare const toolInteractionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"collect">;
+    action: z.ZodString;
+    initialValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fromOutput: z.ZodString;
+    }, z.core.$strict>>>;
+    fields: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        control: z.ZodEnum<{
+            email: "email";
+            text: "text";
+            textarea: "textarea";
+            phone: "phone";
+            url: "url";
+            select: "select";
+            consent: "consent";
+        }>;
+        private: z.ZodOptional<z.ZodLiteral<true>>;
+        optional: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    review: z.ZodLiteral<"all">;
+    outcome: z.ZodObject<{
+        success: z.ZodString;
+    }, z.core.$strict>;
+    confirmationExpiry: z.ZodOptional<z.ZodObject<{
+        seconds: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ToolInteractionManifest = z.infer<typeof toolInteractionSchema>;
+//# sourceMappingURL=interaction-schema.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/manifest/interaction-schema.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { NAME_PATTERN } from './naming.js';
+/**
+ * The `collect` interaction block (ADR 0240): bounded metadata on an opener tool describing which
+ * fields a platform renderer collects for one confirmed action, which are private, what is reviewed,
+ * and what to say on success. It carries meaning only: no layout, ordering script or screen language.
+ * Field, action and output references are checked against the declared tools by the compile pass
+ * (`interaction-validation.ts`), which also bounds `confirmationExpiry` so a bad value reports its own
+ * code instead of a shape error.
+ */
+export const COLLECT_CONTROLS = [
+    'text',
+    'textarea',
+    'email',
+    'phone',
+    'url',
+    'select',
+    'consent',
+];
+const MAX_COLLECT_FIELDS = 32;
+const MAX_PROPERTY_KEY_CHARS = 128;
+const MAX_OUTCOME_CHARS = 280;
+const propertyKeySchema = z.string().min(1).max(MAX_PROPERTY_KEY_CHARS);
+const collectFieldSchema = z
+    .object({
+    key: propertyKeySchema,
+    control: z.enum(COLLECT_CONTROLS),
+    /** Never enters the conversation model, transcript, logs or diagnostics. Opt-in per field. */
+    private: z.literal(true).optional(),
+    /** The person may leave it blank; the renderer submits the schema's empty value. */
+    optional: z.literal(true).optional(),
+})
+    .strict();
+export const toolInteractionSchema = z
+    .object({
+    kind: z.literal('collect'),
+    /** The confirmed action tool this collection prepares, by name. */
+    action: z.string().regex(NAME_PATTERN),
+    /** Action input property -> the opener output property that seeds it. */
+    initialValues: z
+        .record(propertyKeySchema, z.object({ fromOutput: propertyKeySchema }).strict())
+        .optional(),
+    fields: z
+        .array(collectFieldSchema)
+        .min(1)
+        .max(MAX_COLLECT_FIELDS)
+        .superRefine((fields, ctx) => {
+        const seen = new Set();
+        for (const field of fields) {
+            if (seen.has(field.key)) {
+                ctx.addIssue({ code: 'custom', message: `duplicate field key "${field.key}"` });
+            }
+            seen.add(field.key);
+        }
+    }),
+    review: z.literal('all'),
+    outcome: z.object({ success: z.string().trim().min(1).max(MAX_OUTCOME_CHARS) }).strict(),
+    /** A developer may only shorten the profile default; the compile pass checks the bound. */
+    confirmationExpiry: z.object({ seconds: z.number() }).strict().optional(),
+})
+    .strict();
+//# sourceMappingURL=interaction-schema.js.map

package/node_modules/@noodle-borg/compiler/dist/manifest/interaction-validation.js

@@ -0,0 +1,220 @@
+/**
+ * Compile-time checks for the `collect` interaction block (ADR 0240). Every field must be an input of
+ * the action it prepares with a control its schema can honor; every required action input must be
+ * collected or seeded from the opener's output; consent is a single fixed-true boolean; and the
+ * developer may only shorten the confirmation expiry within the platform ceiling. Valid blocks are
+ * emitted keyed by opener tool as system-owned artifact data, never onto the MCP-visible descriptor.
+ */
+/** The 24-hour platform ceiling (email profile default); every profile default sits below it. */
+const MAX_CONFIRMATION_EXPIRY_SECONDS = 86_400;
+export function compileToolInteractions(tools, artifactTools, errors) {
+    const byName = new Map(artifactTools.map((tool) => [tool.name, tool]));
+    const emitted = {};
+    tools.forEach((tool, index) => {
+        if (tool.interaction === undefined)
+            return;
+        const opener = byName.get(tool.name);
+        if (opener === undefined)
+            return; // a structural error on this tool was already recorded
+        const before = errors.length;
+        validateCollect(tool.interaction, opener, byName, `tools.${index}.interaction`, errors);
+        if (errors.length === before)
+            emitted[tool.name] = toArtifact(tool.interaction);
+    });
+    return Object.keys(emitted).length > 0 ? emitted : undefined;
+}
+function validateCollect(interaction, opener, byName, path, errors) {
+    const action = byName.get(interaction.action);
+    if (action === undefined) {
+        errors.push({
+            code: 'interaction_action_invalid',
+            path: `${path}.action`,
+            message: `interaction action "${interaction.action}" is not a declared tool`,
+        });
+        return;
+    }
+    if (action.annotations?.confirm !== true || action.annotations?.readOnlyHint === true) {
+        errors.push({
+            code: 'interaction_action_invalid',
+            path: `${path}.action`,
+            message: `interaction action "${action.name}" must set { confirm: true } and must not be read-only`,
+        });
+        return;
+    }
+    const inputs = objectProperties(action.inputSchema);
+    const required = new Set(stringList(action.inputSchema.required));
+    const outputs = objectProperties(opener.outputSchema);
+    const covered = new Set();
+    let consents = 0;
+    interaction.fields.forEach((field, index) => {
+        const fieldPath = `${path}.fields.${index}`;
+        const property = inputs[field.key];
+        if (property === undefined) {
+            errors.push({
+                code: 'interaction_field_unknown',
+                path: fieldPath,
+                message: `field "${field.key}" is not an input of action "${action.name}"`,
+            });
+            return;
+        }
+        covered.add(field.key);
+        if (field.control === 'consent')
+            consents += 1;
+        const mismatch = controlMismatch(field.control, property);
+        if (mismatch !== undefined) {
+            errors.push({
+                code: 'interaction_field_control_mismatch',
+                path: fieldPath,
+                message: `field "${field.key}" uses control "${field.control}" but its input schema ${mismatch}`,
+            });
+        }
+        if (field.optional === true) {
+            if (required.has(field.key) && !acceptsEmptyString(property)) {
+                errors.push({
+                    code: 'interaction_field_missing',
+                    path: fieldPath,
+                    message: `optional field "${field.key}" is required by action "${action.name}" and rejects the empty value; make the property optional or let it accept ""`,
+                });
+            }
+        }
+        else if (!required.has(field.key)) {
+            errors.push({
+                code: 'interaction_field_missing',
+                path: fieldPath,
+                message: `field "${field.key}" is not required by action "${action.name}"; mark it optional: true or require it`,
+            });
+        }
+    });
+    if (consents > 1) {
+        errors.push({
+            code: 'interaction_consent_invalid',
+            path: `${path}.fields`,
+            message: 'a collect interaction poses at most one consent question',
+        });
+    }
+    for (const [target, source] of Object.entries(interaction.initialValues ?? {})) {
+        const valuePath = `${path}.initialValues.${target}`;
+        if (inputs[target] === undefined) {
+            errors.push({
+                code: 'interaction_initial_value_unknown',
+                path: valuePath,
+                message: `initial value "${target}" is not an input of action "${action.name}"`,
+            });
+        }
+        else {
+            covered.add(target);
+        }
+        if (outputs[source.fromOutput] === undefined) {
+            errors.push({
+                code: 'interaction_initial_value_unknown',
+                path: `${valuePath}.fromOutput`,
+                message: `initial value "${target}" reads "${source.fromOutput}", which "${opener.name}" does not output`,
+            });
+        }
+    }
+    for (const key of required) {
+        if (covered.has(key))
+            continue;
+        errors.push({
+            code: 'interaction_field_missing',
+            path: `${path}.fields`,
+            message: `required input "${key}" of action "${action.name}" is neither a field nor an initial value`,
+        });
+    }
+    const seconds = interaction.confirmationExpiry?.seconds;
+    if (seconds !== undefined &&
+        !(Number.isInteger(seconds) && seconds >= 1 && seconds <= MAX_CONFIRMATION_EXPIRY_SECONDS)) {
+        errors.push({
+            code: 'interaction_expiry_invalid',
+            path: `${path}.confirmationExpiry.seconds`,
+            message: `confirmationExpiry.seconds must be a whole number from 1 to ${MAX_CONFIRMATION_EXPIRY_SECONDS}`,
+        });
+    }
+}
+/** Why `control` cannot render `property`, or undefined when the schema supports it. */
+function controlMismatch(control, property) {
+    switch (control) {
+        case 'consent':
+            return property.type === 'boolean' && isFixedTrue(property)
+                ? undefined
+                : 'is not a boolean fixed to true';
+        case 'select':
+            return property.type === 'string' && isStringEnum(property.enum)
+                ? undefined
+                : 'is not an enum of strings';
+        case 'email':
+            if (property.type !== 'string')
+                return 'is not a string';
+            return property.format === undefined || property.format === 'email'
+                ? undefined
+                : `declares format "${String(property.format)}"`;
+        default:
+            return property.type === 'string' ? undefined : 'is not a string';
+    }
+}
+function isFixedTrue(property) {
+    if (property.const === true)
+        return true;
+    return Array.isArray(property.enum) && property.enum.length === 1 && property.enum[0] === true;
+}
+function isStringEnum(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === 'string');
+}
+/**
+ * Whether `""` satisfies a string property, so an optional field the action still requires can be
+ * submitted blank. Any format, a positive minLength, or a pattern/enum/const rejecting `""` means no.
+ */
+function acceptsEmptyString(property) {
+    if (property.type !== 'string' || property.format !== undefined)
+        return false;
+    if (typeof property.minLength === 'number' && property.minLength > 0)
+        return false;
+    if (property.const !== undefined && property.const !== '')
+        return false;
+    if (Array.isArray(property.enum) && !property.enum.includes(''))
+        return false;
+    return typeof property.pattern === 'string' ? patternMatchesEmpty(property.pattern) : true;
+}
+function patternMatchesEmpty(pattern) {
+    for (const flags of ['u', '']) {
+        try {
+            return new RegExp(pattern, flags).test('');
+        }
+        catch {
+            // An invalid pattern under this flag set; try the next, then fail closed.
+        }
+    }
+    return false;
+}
+function objectProperties(schema) {
+    const properties = schema?.properties;
+    if (typeof properties !== 'object' || properties === null || Array.isArray(properties))
+        return {};
+    return Object.fromEntries(Object.entries(properties).flatMap(([key, value]) => typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? [[key, value]]
+        : []));
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function toArtifact(interaction) {
+    return {
+        kind: 'collect',
+        action: interaction.action,
+        fields: interaction.fields.map((field) => ({
+            key: field.key,
+            control: field.control,
+            ...(field.private === true ? { private: true } : {}),
+            ...(field.optional === true ? { optional: true } : {}),
+        })),
+        ...(interaction.initialValues === undefined
+            ? {}
+            : { initialValues: interaction.initialValues }),
+        review: 'all',
+        outcome: { success: interaction.outcome.success },
+        ...(interaction.confirmationExpiry === undefined
+            ? {}
+            : { confirmationExpirySeconds: interaction.confirmationExpiry.seconds }),
+    };
+}
+//# sourceMappingURL=interaction-validation.js.map

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -11,10 +11,10 @@ export declare const manifestV1Schema: z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -557,10 +557,10 @@ export declare const manifestV2Schema: z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -1238,6 +1238,34 @@ export declare const manifestV2Schema: z.ZodObject<{
             output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
         contextProvider: z.ZodOptional<z.ZodLiteral<true>>;
+        interaction: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"collect">;
+            action: z.ZodString;
+            initialValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                fromOutput: z.ZodString;
+            }, z.core.$strict>>>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                control: z.ZodEnum<{
+                    email: "email";
+                    text: "text";
+                    textarea: "textarea";
+                    phone: "phone";
+                    url: "url";
+                    select: "select";
+                    consent: "consent";
+                }>;
+                private: z.ZodOptional<z.ZodLiteral<true>>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            review: z.ZodLiteral<"all">;
+            outcome: z.ZodObject<{
+                success: z.ZodString;
+            }, z.core.$strict>;
+            confirmationExpiry: z.ZodOptional<z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
@@ -1285,10 +1313,10 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -1830,10 +1858,10 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodOptional<z.ZodObject<{
         handles: z.ZodRecord<z.ZodString, z.ZodObject<{
             kind: z.ZodEnum<{
+                search: "search";
                 session: "session";
                 draft: "draft";
                 selection: "selection";
-                search: "search";
                 cart: "cart";
                 workflow: "workflow";
             }>;
@@ -2511,6 +2539,34 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
         contextProvider: z.ZodOptional<z.ZodLiteral<true>>;
+        interaction: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"collect">;
+            action: z.ZodString;
+            initialValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                fromOutput: z.ZodString;
+            }, z.core.$strict>>>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                control: z.ZodEnum<{
+                    email: "email";
+                    text: "text";
+                    textarea: "textarea";
+                    phone: "phone";
+                    url: "url";
+                    select: "select";
+                    consent: "consent";
+                }>;
+                private: z.ZodOptional<z.ZodLiteral<true>>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>;
+            review: z.ZodLiteral<"all">;
+            outcome: z.ZodObject<{
+                success: z.ZodString;
+            }, z.core.$strict>;
+            confirmationExpiry: z.ZodOptional<z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -7,6 +7,7 @@ import { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES } from '../wi
 import { agentGuideSchema } from './agent-guide-schema.js';
 import { serverAuthSchema, serverAuthV2Schema } from './auth-schema.js';
 import { assistantOriginOrVariableSchema, httpsUrlSchema, managedVariableExpressionSchema, serverBrandingSchema, } from './branding-schema.js';
+import { toolInteractionSchema } from './interaction-schema.js';
 import { NAME_PATTERN } from './naming.js';
 /**
  * Zod schema for Core v1 and v2 manifests (ADRs 0150 and 0157). V1 remains accepted unchanged;
@@ -115,7 +116,12 @@ const toolSchema = z.object({
         .optional(),
     fulfilment: fulfilmentSchema,
 });
-const toolV2Schema = toolSchema.extend({ contextProvider: z.literal(true).optional() });
+const toolV2Schema = toolSchema.extend({
+    contextProvider: z.literal(true).optional(),
+    // Additive optional field: a v1.x minor under ADR 0150. Bounded `collect` interaction metadata
+    // (ADR 0240) an opener tool declares for one confirmed action; references are checked in compile().
+    interaction: toolInteractionSchema.optional(),
+});
 /**
  * An MCP resource. Like a tool, it carries a `fulfilment` (it can return a constant or call connectors);
  * its `uri` is a fixed URI or a simple `{var}` URI template (validated in compile()). The compile pass

package/node_modules/@noodle-borg/compiler/dist/manifest/website-projection.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactPrompt, ArtifactResource, ArtifactTool } from '../artifact/types.js';
+import type { ArtifactCollectInteraction, ArtifactPrompt, ArtifactResource, ArtifactTool, OperationRef } from '../artifact/types.js';
 import type { CompileError } from '../errors.js';
 /**
  * Compile-time enforcement of website assistant surfaces (ADR 0201, amended 2026-08-12). These are
@@ -36,9 +36,17 @@ export interface WebsiteProjectionSurfaces {
     readonly knowledge?: readonly {
         readonly name: string;
     }[] | undefined;
+    /** `collect` interactions keyed by opener (ADR 0240); a messaging surface presents them natively. */
+    readonly interactions?: Readonly<Record<string, ArtifactCollectInteraction>> | undefined;
+    /** Declared connector aliases, so a shape-only operation ref still names its connector id. */
+    readonly connectors?: Readonly<Record<string, {
+        readonly id: string;
+    }>> | undefined;
 }
 /** A tool touches identity when it reads `${user}` or requires verified claims (ADR 0185). */
 export declare function anonymousBehavior(tool: ArtifactTool): 'public-safe' | 'requires-identity';
 export declare function validateWebsiteProjection(assistant: AssistantProjectionInput | undefined, surfaces: WebsiteProjectionSurfaces): readonly CompileError[];
+/** Resolved refs carry the connector id; a shape-only ref is looked up through its declared alias. */
+export declare function isNativeRecordsOperation(operation: OperationRef, connectors: WebsiteProjectionSurfaces['connectors']): boolean;
 export {};
 //# sourceMappingURL=website-projection.d.ts.map