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

# Answer a Hug

> Sends your answer, or replaces it — one answer per person, the latest wins. `values` are keyed
by requested-input name and checked against the Hug's inputs; a file input takes
`{ artifact_id }` from Upload a file (with `hug_id` and `requested_input`). The answer goes to
the agent straight away.

Requires a realm member (or higher) with the `runs.view` permission on the realm that owns the hug given by `hug_id`. Addressed to the caller.



## OpenAPI

````yaml /openapi/hub-by-tag/hub-hugs.yaml post /v1/hugs/respond
openapi: 3.0.3
info:
  title: 'CliqHub API: Hugs'
  version: 1.0.0
  description: >-
    A Hug is a run asking people for input: an agent (a review gate, or its own
    `ctx.ask`) opens

    one with a prompt, context (markdown, files, check results, an earlier
    conversation) and the

    inputs it needs — text, number, boolean, a choice, a file, a channel.
    CliqHub posts it to the

    Hug's channels; anyone it reaches who can view runs in the realm answers on
    the Hug page, and

    can change their answer while it is open. Every answer is sent back to the
    agent, which decides

    when it has heard enough and closes the Hug; it expires after its time (at
    most 7 days).


    Seeing a Hug needs `runs.view` on its realm; answering also needs the Hug to
    be addressed to

    you (your own channel, or one of its shared channels). `create`, `close` and
    `get_events` are

    for daemons only.
servers:
  - url: https://{host}
    variables:
      host:
        default: cliqhub.io
        description: CliqHub host
security: []
tags:
  - name: Hugs
    description: >-
      A Hug is a run asking people for input: an agent (a review gate, or its
      own `ctx.ask`) opens

      one with a prompt, context (markdown, files, check results, an earlier
      conversation) and the

      inputs it needs — text, number, boolean, a choice, a file, a channel.
      CliqHub posts it to the

      Hug's channels; anyone it reaches who can view runs in the realm answers
      on the Hug page, and

      can change their answer while it is open. Every answer is sent back to the
      agent, which decides

      when it has heard enough and closes the Hug; it expires after its time (at
      most 7 days).


      Seeing a Hug needs `runs.view` on its realm; answering also needs the Hug
      to be addressed to

      you (your own channel, or one of its shared channels). `create`, `close`
      and `get_events` are

      for daemons only.
paths:
  /v1/hugs/respond:
    post:
      tags:
        - Hugs
      summary: Answer a Hug
      description: >-
        Sends your answer, or replaces it — one answer per person, the latest
        wins. `values` are keyed

        by requested-input name and checked against the Hug's inputs; a file
        input takes

        `{ artifact_id }` from Upload a file (with `hug_id` and
        `requested_input`). The answer goes to

        the agent straight away.


        Requires a realm member (or higher) with the `runs.view` permission on
        the realm that owns the hug given by `hug_id`. Addressed to the caller.
      operationId: POST_v1_hugs_respond
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                hug_id:
                  type: string
                  minLength: 1
                  description: The Hug.
                values:
                  type: object
                  additionalProperties: true
                  description: Your answers, keyed by requested-input name.
                comment:
                  type: string
                  maxLength: 10
                  description: An optional note with your answer.
              required:
                - hug_id
                - values
            examples:
              default:
                value:
                  hug_id: 6c2d1e0f-9a8b-4c7d-8e6f-5a4b3c2d1e0f
                  values:
                    decision: approve
                    comment: LGTM
      responses:
        '200':
          description: Success.
          content:
            application/json:
              schema:
                type: object
                required:
                  - ok
                  - data
                properties:
                  ok:
                    type: boolean
                    enum:
                      - true
                    description: Always `true` on success.
                  data:
                    type: object
                    properties:
                      response_id:
                        type: string
                      seq:
                        type: integer
                        description: The event number the agent receives.
              example:
                ok: true
                data:
                  response_id: 3f2e1d0c-9b8a-4c7d-8e6f-5a4b3c2d1e0f
                  seq: 1
        '401':
          description: >-
            `unauthorized`: No `Authorization` header, or the token is
            malformed, expired or revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                unauthorized:
                  summary: unauthorized
                  value:
                    ok: false
                    error:
                      code: unauthorized
                      message: Authentication required
        '403':
          description: >-
            `forbidden`: You can see the record but your role in its realm is
            too low or lacks the required permission.


            `forbidden`: The Hug wasn't addressed to you, or you can't view runs
            in its realm.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                forbidden:
                  summary: forbidden
                  value:
                    ok: false
                    error:
                      code: forbidden
                      message: You do not have access to do this
                forbidden (endpoint):
                  summary: forbidden (endpoint)
                  value:
                    ok: false
                    error: >-
                      This Hug was not sent to you, or you cannot view runs in
                      its realm
                    code: forbidden
        '404':
          description: >-
            `not_found`: The record does not exist or is in a realm you cannot
            see (404 rather than 403, so its existence is not revealed).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                not_found:
                  summary: not_found
                  value:
                    ok: false
                    error:
                      code: not_found
                      message: Not found
        '409':
          description: '`HUG_CLOSED`: The requester closed it, or it was cancelled.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                HUG_CLOSED:
                  summary: HUG_CLOSED
                  value:
                    ok: false
                    error: This Hug is closed
                    code: HUG_CLOSED
        '410':
          description: '`HUG_EXPIRED`: It is past its expiry.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                HUG_EXPIRED:
                  summary: HUG_EXPIRED
                  value:
                    ok: false
                    error: This Hug has expired
                    code: HUG_EXPIRED
        '422':
          description: >-
            `invalid_params`: The body fails the request schema: a required
            field is missing or a value has the wrong type or format. The
            message lists every issue as `field: problem`.


            `invalid_values`: A value is missing, of the wrong type, or breaks a
            constraint (one `name: problem` per input).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                invalid_params:
                  summary: invalid_params
                  value:
                    ok: false
                    error: 'hug_id: Required'
                    code: invalid_params
                invalid_values:
                  summary: invalid_values
                  value:
                    ok: false
                    error: 'decision: required; risk: must be at most 5'
                    code: invalid_values
        '500':
          description: >-
            `internal_error`: An unexpected server fault. Retry later; if it
            persists, report it with the time of the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                internal_error:
                  summary: internal_error
                  value:
                    ok: false
                    error: Internal server error
                    code: internal_error
      security:
        - BearerAuth: []
components:
  schemas:
    HubErr:
      type: object
      required:
        - ok
        - error
      description: >-
        Every failure. Route-policy denials (401/403/404, and 400 when neither
        realm_id nor org_id was sent) answer `error` as `{ code, message }`;
        errors raised by the endpoint answer `error` as the message with the
        code beside it in `code`. Every error has a code. See
        [Errors](/hub-api/errors).
      properties:
        ok:
          type: boolean
          description: Always false on error
        error:
          description: The message, or `{ code, message }` for an access denial.
          oneOf:
            - type: string
            - type: object
              required:
                - code
                - message
              properties:
                code:
                  type: string
                message:
                  type: string
        code:
          type: string
          description: Stable error code of an endpoint error.
        details:
          type: object
          additionalProperties: true
          description: Structured detail, when there is some.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: cliq_tok_* | cliq_dt_*
      description: >-
        User PAT (`cliq_tok_…`, including session-scoped) or realm token
        (`cliq_dt_…`).

````

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