> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tai42.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# React to an open form interaction

> React to an OPEN reacting form through the AUTHENTICATED in-app door — the ``channel=None`` surface.

The SIBLING of the authenticated answer door, under the SAME authenticated correlation:
the same existence/format/status guards and the SAME audience gate (a restricted caller
may react only to a form addressed to its identity). It then runs the ONE ``react``
chokepoint, which asserts the form is open, type-validates the partial values, runs the
asker's handler under its stored identity with a deadline, validates the returned update,
and returns it. STATELESS: no answer is recorded, the interaction is never resolved, the
stored request is never rewritten. A closed form is a ``409``, a malformed request a
``400``, and a handler that raises or times out a loud ``502`` (never a stale value).



## OpenAPI

````yaml /openapi.json post /api/interactions/{interaction_id}/react
openapi: 3.1.0
info:
  description: The operator HTTP surface served under /api/*.
  title: tai42-skeleton API
  version: 21.5.0
servers: []
security: []
paths:
  /api/interactions/{interaction_id}/react:
    post:
      tags:
        - interactions
      summary: React to an open form interaction
      description: >-
        React to an OPEN reacting form through the AUTHENTICATED in-app door —
        the ``channel=None`` surface.


        The SIBLING of the authenticated answer door, under the SAME
        authenticated correlation:

        the same existence/format/status guards and the SAME audience gate (a
        restricted caller

        may react only to a form addressed to its identity). It then runs the
        ONE ``react``

        chokepoint, which asserts the form is open, type-validates the partial
        values, runs the

        asker's handler under its stored identity with a deadline, validates the
        returned update,

        and returns it. STATELESS: no answer is recorded, the interaction is
        never resolved, the

        stored request is never rewritten. A closed form is a ``409``, a
        malformed request a

        ``400``, and a handler that raises or times out a loud ``502`` (never a
        stale value).
      operationId: post_api_interactions_interaction_id_react
      parameters:
        - in: path
          name: interaction_id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/InteractionReact'
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  data:
                    $ref: '#/components/schemas/InteractionReactionResult'
                required:
                  - data
                type: object
          description: Success.
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Malformed request.
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Missing or invalid api key.
        '403':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Forbidden.
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Resource not found.
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Conflict with the current resource state.
        '413':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Request body too large.
        '502':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: Error.
      security:
        - ApiKeyAuth: []
components:
  schemas:
    InteractionReact:
      description: >-
        A mid-form reaction to an OPEN reacting form.


        ``event`` is the triggering event (``{"kind", "field"?|"page"?}``) and
        ``values`` the

        partial values filled so far; both are validated at runtime against the
        stored reacting

        form (its declared triggers and schema).
      properties:
        event:
          additionalProperties: true
          title: Event
          type: object
        values:
          additionalProperties: true
          title: Values
          type: object
      required:
        - event
        - values
      title: InteractionReact
      type: object
    InteractionReactionResult:
      description: >-
        The in-app reaction door's result: the ``interaction_id`` and the
        validated form ``update``.
      properties:
        interaction_id:
          title: Interaction Id
          type: string
        update:
          additionalProperties: true
          title: Update
          type: object
      required:
        - interaction_id
        - update
      title: InteractionReactionResult
      type: object
    Error:
      properties:
        code:
          description: >-
            Stable machine-readable reason a client keys a dedicated error state
            on, present on refusals that opt in (e.g. a 501 not-configured
            refusal). Optional: absent when the error carries only a
            human-readable message.
          type: string
        error:
          type: string
      required:
        - error
      type: object
  securitySchemes:
    ApiKeyAuth:
      in: header
      name: x-api-key
      type: apiKey

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.