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

# Fork a chat into a new chat of its task, or a new task in a sandbox or on one of your computers

> Forks a chat where to says and answers 201 with the new chat. With no body, or to of kind this_task, the new chat is in the same task: it resumes the chat's checkpoint under a new harness session id, starts with a copy of its conversation, and works on the same files, branch and pull request. With to of kind sandbox or computer, the new chat is the main chat of a new task in a sandbox of its own or on one of the caller's computers, which continues the chat, any chat of the task and not the main chat alone. The new chat names the chat in forked_from, and the chat itself is left as it is.

Use this tool when you need to:
- Branch a conversation on the same files, branch and pull request
- Continue a chat in a task of its own, on a new branch, in a sandbox of its own
- Try another direction from where a chat stands without changing that chat

Examples:
- POST /tasks/{taskID}/chats/{chatID}/fork with no body
- POST /tasks/6f1c2a9e-3b7d-4c55-9a2e-0d8b1f4e7c21/chats/0b8e6d52-4f3a-4c1e-9d7b-2a5c8e1f3b90/fork {"to":{"kind":"this_task"}}
- POST /tasks/6f1c2a9e-3b7d-4c55-9a2e-0d8b1f4e7c21/chats/0b8e6d52-4f3a-4c1e-9d7b-2a5c8e1f3b90/fork {"to":{"kind":"sandbox","vm_size":"medium"},"message":"Try the same fix with a cache instead"}

Hints:
- taskID and chatID are lowercase uuids. Any chat of the task forks, its main chat or an archived one included; a chat of another task is 404.
- this_task: the new chat takes the chat's harness, model, effort, mode and connection, has no turn queued, and is shaped as listTaskChats lists it. Send it its next message with respondToTaskChat; one turn runs at a time per workspace, so its turn waits while another chat's runs. message, model and reasoning_effort are refused beside it with 422.
- sandbox: the answer's task_id names the new task, written before the answer, so getTask reads it at once. message is its first prompt; omitted, a prompt that says to continue the work. model and reasoning_effort are what GET /projects/{projectID}/start-options lists for the chat's agent; omitted, the chat's own where that list has them, else its defaults; one it does not list is 422. vm_size omitted is the project's default size. The new task keeps the chat's agent and mode, runs on the caller's default connection for that agent, takes the project's auto-fix settings, and is bound to this task's base branch. Its branch is a new branch cut from this task's branch, carrying every change in the workspace that git does not ignore. A stopped workspace is started to read it. If the request is cut off after the push, the branch may have been pushed and the task made: repeat it with the same idempotency_key, or list the project's tasks before forking again.
- idempotency_key is an optional uuid, for any to, scoped to the caller (the person, whatever credential they use) and this task. A repeat with the same key, from the same chat and with the same body, answers 201 with the chat the first one made as it stands now, and pushes and creates nothing. A repeat while the first is still at work is 409 fork_in_progress. The same key with another body or on another chat of the task is 409 idempotency_key_reused. A fork that is refused or fails frees its key. One cut off before its new chat was committed frees its key after ten minutes, and a branch it pushed stays in the repository with no task; one cut off after the commit keeps its key, and a repeat answers its chat.
- Refused as the destination's fork option (getTaskChatForkOptions) shows its can.fork, with its code and sentence: 409 turn_running while a turn of the chat is queued, running or stopped and waiting to run again, task_awaiting_tool_response while its agent waits on a question, no_checkpoint_yet before its first turn has left a checkpoint, and fork_unsupported for an OpenCode chat; 403 user_suspended or org_suspended for a suspended account or organization.
- A fork to a sandbox the account cannot start a task in now is refused, before anything is pushed, as createTask refuses one: 402 with the account's standing (billing_blocked, credits_exhausted, org_task_concurrency_exceeded) for the cheapest size, the code and sentence the option shows. A null field is refused with 422.
- A fork to a sandbox is also refused with 409 and the reason's own code and sentence as forkTask's is: task_has_no_repository, workspace_gone, workspace_outdated, workspace_start_failed, chat_moved, credential_named_file, too_large, detached_head, no_commit, no_origin, branch_exists and push_failed; then as createTask refuses the new task: a connection refusal or mcp_server_not_connected with 409, and 402 for a task the organization cannot admit.
- computer: a new task on one of the caller's own computers, started there: the chat's workspace pushes its work to the fork's branch, and the computer makes a work tree on it and places the chat's session, which the new task's main chat continues. The answer is that main chat, written before the answer: its task's start reads pending, and the main chat queued with task_start_pending, until the computer has placed it. message is its first prompt, a prompt that says to continue the work when omitted: at most 64 KiB, and not a slash command (422). model and reasoning_effort are what that computer's fork option (getTaskChatForkOptions) lists; omitted, its defaults; one it does not list is 422; default and no thinking level reach the computer as no setting. The start runs under the sign-in or API key the request carries. Refused as that option's can.fork shows it: 409 fork_unsupported, computer_cli_outdated, no_work_tree_folder, computer_unreachable, agent_starts_off or no_checkout_on_computer, 403 credential_kind_not_admitted; then as a fork to a sandbox's push is. A computer that is not the caller's is 404. A repeat with the same idempotency_key after the new task is written answers its main chat however its start has gone since, and makes no second task, branch or start.
- Use forkTask to fork a task's main chat into a new task that answers the task instead of its chat.
- Restricted to the task's creator or an admin or owner of its organization: another member is refused with 403 control_forbidden, a viewer or billing member with 403 org_role_insufficient, a suspended organization with 403 org_suspended, and a task the caller cannot see is 404; 503 when the membership check is unavailable.
- A chat on its person's computer forks to a sandbox or to one of the caller's computers, its own included: the answer is the new task's main chat, written before the answer with the task, which reads queued while it waits on the chat's computer, its start pending with turn_running while the chat's turn runs there (can.fork notes waits_for_turn_end; the computer waits up to 30 minutes) and handing_over while the computer ships the session and pushes its work. A hand-over that fails, is missed (no poll took it before it expired, or no report came within 35 minutes of the one that did) or is cancelled by archiving the task leaves the task errored, its start failed with the reason, and the chat untouched. The chat's messages wait with chat_being_forked meanwhile. Without idempotency_key, a fork of the chat while its earlier hand-over is on its way answers the chat that hand-over made. Refused as the chat's can.fork shows it: 403 control_forbidden for anyone but its person, credential_kind_not_admitted for an agent's credential; 409 computer_unreachable, session_file_missing, too_large, session_gone, computer_cli_outdated, fork_unsupported. this_task is 409 chats_not_addable.
- From a chat on a computer to a sandbox: the account's standing for a new task is read as the fork is asked and refuses it as a fork from a sandbox is refused (402 billing_blocked, credits_exhausted, org_task_concurrency_exceeded). Once the computer has shipped, the task runs as any new task does; what only then can be known, runtime admission, MCP servers and the connection, is asked as the hand-over settles, and a refusal fails the start create_refused with the refusal's own sentence.
- From a chat on a computer to a computer: refused as that computer's fork option shows its can.fork, as a fork from a sandbox to a computer is, and 404 for a computer that is not the caller's. The new task's work tree is on the branch the chat's computer pushes. Once the hand-over has shipped the computer's own start is written, under the sign-in or API key the fork was asked with, and the task's start reads it: making_work_tree, placing_session, computer_unreachable while that computer sleeps, then what holds its first run back; it waits up to 24 hours from the ship. A start that fails there leaves the task errored and the chat untouched, and the branch the chat's computer pushed stays in the repository. model and reasoning_effort default to the chat's own where that computer lists them, else to what its session last ran on where it lists that, else to default.



## OpenAPI

````yaml api-reference/openapi.json POST /tasks/{taskID}/chats/{chatID}/fork
openapi: 3.1.0
info:
  title: Aether API
  version: 0.1.0
servers:
  - url: https://api.runaether.dev
security:
  - bearerAuth: []
paths:
  /tasks/{taskID}/chats/{chatID}/fork:
    post:
      tags:
        - tasks
      summary: >-
        Fork a chat into a new chat of its task, or a new task in a sandbox or
        on one of your computers
      description: >-
        Forks a chat where to says and answers 201 with the new chat. With no
        body, or to of kind this_task, the new chat is in the same task: it
        resumes the chat's checkpoint under a new harness session id, starts
        with a copy of its conversation, and works on the same files, branch and
        pull request. With to of kind sandbox or computer, the new chat is the
        main chat of a new task in a sandbox of its own or on one of the
        caller's computers, which continues the chat, any chat of the task and
        not the main chat alone. The new chat names the chat in forked_from, and
        the chat itself is left as it is.


        Use this tool when you need to:

        - Branch a conversation on the same files, branch and pull request

        - Continue a chat in a task of its own, on a new branch, in a sandbox of
        its own

        - Try another direction from where a chat stands without changing that
        chat


        Examples:

        - POST /tasks/{taskID}/chats/{chatID}/fork with no body

        - POST
        /tasks/6f1c2a9e-3b7d-4c55-9a2e-0d8b1f4e7c21/chats/0b8e6d52-4f3a-4c1e-9d7b-2a5c8e1f3b90/fork
        {"to":{"kind":"this_task"}}

        - POST
        /tasks/6f1c2a9e-3b7d-4c55-9a2e-0d8b1f4e7c21/chats/0b8e6d52-4f3a-4c1e-9d7b-2a5c8e1f3b90/fork
        {"to":{"kind":"sandbox","vm_size":"medium"},"message":"Try the same fix
        with a cache instead"}


        Hints:

        - taskID and chatID are lowercase uuids. Any chat of the task forks, its
        main chat or an archived one included; a chat of another task is 404.

        - this_task: the new chat takes the chat's harness, model, effort, mode
        and connection, has no turn queued, and is shaped as listTaskChats lists
        it. Send it its next message with respondToTaskChat; one turn runs at a
        time per workspace, so its turn waits while another chat's runs.
        message, model and reasoning_effort are refused beside it with 422.

        - sandbox: the answer's task_id names the new task, written before the
        answer, so getTask reads it at once. message is its first prompt;
        omitted, a prompt that says to continue the work. model and
        reasoning_effort are what GET /projects/{projectID}/start-options lists
        for the chat's agent; omitted, the chat's own where that list has them,
        else its defaults; one it does not list is 422. vm_size omitted is the
        project's default size. The new task keeps the chat's agent and mode,
        runs on the caller's default connection for that agent, takes the
        project's auto-fix settings, and is bound to this task's base branch.
        Its branch is a new branch cut from this task's branch, carrying every
        change in the workspace that git does not ignore. A stopped workspace is
        started to read it. If the request is cut off after the push, the branch
        may have been pushed and the task made: repeat it with the same
        idempotency_key, or list the project's tasks before forking again.

        - idempotency_key is an optional uuid, for any to, scoped to the caller
        (the person, whatever credential they use) and this task. A repeat with
        the same key, from the same chat and with the same body, answers 201
        with the chat the first one made as it stands now, and pushes and
        creates nothing. A repeat while the first is still at work is 409
        fork_in_progress. The same key with another body or on another chat of
        the task is 409 idempotency_key_reused. A fork that is refused or fails
        frees its key. One cut off before its new chat was committed frees its
        key after ten minutes, and a branch it pushed stays in the repository
        with no task; one cut off after the commit keeps its key, and a repeat
        answers its chat.

        - Refused as the destination's fork option (getTaskChatForkOptions)
        shows its can.fork, with its code and sentence: 409 turn_running while a
        turn of the chat is queued, running or stopped and waiting to run again,
        task_awaiting_tool_response while its agent waits on a question,
        no_checkpoint_yet before its first turn has left a checkpoint, and
        fork_unsupported for an OpenCode chat; 403 user_suspended or
        org_suspended for a suspended account or organization.

        - A fork to a sandbox the account cannot start a task in now is refused,
        before anything is pushed, as createTask refuses one: 402 with the
        account's standing (billing_blocked, credits_exhausted,
        org_task_concurrency_exceeded) for the cheapest size, the code and
        sentence the option shows. A null field is refused with 422.

        - A fork to a sandbox is also refused with 409 and the reason's own code
        and sentence as forkTask's is: task_has_no_repository, workspace_gone,
        workspace_outdated, workspace_start_failed, chat_moved,
        credential_named_file, too_large, detached_head, no_commit, no_origin,
        branch_exists and push_failed; then as createTask refuses the new task:
        a connection refusal or mcp_server_not_connected with 409, and 402 for a
        task the organization cannot admit.

        - computer: a new task on one of the caller's own computers, started
        there: the chat's workspace pushes its work to the fork's branch, and
        the computer makes a work tree on it and places the chat's session,
        which the new task's main chat continues. The answer is that main chat,
        written before the answer: its task's start reads pending, and the main
        chat queued with task_start_pending, until the computer has placed it.
        message is its first prompt, a prompt that says to continue the work
        when omitted: at most 64 KiB, and not a slash command (422). model and
        reasoning_effort are what that computer's fork option
        (getTaskChatForkOptions) lists; omitted, its defaults; one it does not
        list is 422; default and no thinking level reach the computer as no
        setting. The start runs under the sign-in or API key the request
        carries. Refused as that option's can.fork shows it: 409
        fork_unsupported, computer_cli_outdated, no_work_tree_folder,
        computer_unreachable, agent_starts_off or no_checkout_on_computer, 403
        credential_kind_not_admitted; then as a fork to a sandbox's push is. A
        computer that is not the caller's is 404. A repeat with the same
        idempotency_key after the new task is written answers its main chat
        however its start has gone since, and makes no second task, branch or
        start.

        - Use forkTask to fork a task's main chat into a new task that answers
        the task instead of its chat.

        - Restricted to the task's creator or an admin or owner of its
        organization: another member is refused with 403 control_forbidden, a
        viewer or billing member with 403 org_role_insufficient, a suspended
        organization with 403 org_suspended, and a task the caller cannot see is
        404; 503 when the membership check is unavailable.

        - A chat on its person's computer forks to a sandbox or to one of the
        caller's computers, its own included: the answer is the new task's main
        chat, written before the answer with the task, which reads queued while
        it waits on the chat's computer, its start pending with turn_running
        while the chat's turn runs there (can.fork notes waits_for_turn_end; the
        computer waits up to 30 minutes) and handing_over while the computer
        ships the session and pushes its work. A hand-over that fails, is missed
        (no poll took it before it expired, or no report came within 35 minutes
        of the one that did) or is cancelled by archiving the task leaves the
        task errored, its start failed with the reason, and the chat untouched.
        The chat's messages wait with chat_being_forked meanwhile. Without
        idempotency_key, a fork of the chat while its earlier hand-over is on
        its way answers the chat that hand-over made. Refused as the chat's
        can.fork shows it: 403 control_forbidden for anyone but its person,
        credential_kind_not_admitted for an agent's credential; 409
        computer_unreachable, session_file_missing, too_large, session_gone,
        computer_cli_outdated, fork_unsupported. this_task is 409
        chats_not_addable.

        - From a chat on a computer to a sandbox: the account's standing for a
        new task is read as the fork is asked and refuses it as a fork from a
        sandbox is refused (402 billing_blocked, credits_exhausted,
        org_task_concurrency_exceeded). Once the computer has shipped, the task
        runs as any new task does; what only then can be known, runtime
        admission, MCP servers and the connection, is asked as the hand-over
        settles, and a refusal fails the start create_refused with the refusal's
        own sentence.

        - From a chat on a computer to a computer: refused as that computer's
        fork option shows its can.fork, as a fork from a sandbox to a computer
        is, and 404 for a computer that is not the caller's. The new task's work
        tree is on the branch the chat's computer pushes. Once the hand-over has
        shipped the computer's own start is written, under the sign-in or API
        key the fork was asked with, and the task's start reads it:
        making_work_tree, placing_session, computer_unreachable while that
        computer sleeps, then what holds its first run back; it waits up to 24
        hours from the ship. A start that fails there leaves the task errored
        and the chat untouched, and the branch the chat's computer pushed stays
        in the repository. model and reasoning_effort default to the chat's own
        where that computer lists them, else to what its session last ran on
        where it lists that, else to default.
      operationId: forkTaskChat
      parameters:
        - in: path
          name: taskID
          required: true
          schema:
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
            type: string
        - in: path
          name: chatID
          required: true
          schema:
            format: uuid
            pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ForkChatRequest'
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Chat'
          description: Created
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Unauthorized
        '402':
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/WorkspaceRuntimeAdmissionError'
                  - $ref: >-
                      #/components/schemas/InferenceBalanceExhaustedErrorResponse
          description: Payment Required
        '403':
          content:
            application/json:
              schema:
                anyOf:
                  - oneOf:
                      - $ref: '#/components/schemas/TasksErrorResponse'
                      - $ref: '#/components/schemas/WorkspaceRuntimeAdmissionError'
                  - $ref: '#/components/schemas/OrgAuthorizationErrorResponse'
                  - $ref: '#/components/schemas/ControlForbiddenErrorResponse'
          description: Forbidden
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Not Found
        '409':
          content:
            application/json:
              schema:
                anyOf:
                  - $ref: '#/components/schemas/TasksErrorResponse'
                  - $ref: '#/components/schemas/McpServerNotConnectedErrorResponse'
          description: Conflict
        '410':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Gone
        '422':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Unprocessable Entity
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Internal Server Error
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TasksErrorResponse'
          description: Service Unavailable
components:
  schemas:
    ForkChatRequest:
      additionalProperties: false
      properties:
        idempotency_key:
          description: >-
            Optional client-generated UUID, scoped to the caller and the chat's
            task. A repeat with the same key, chat and body answers the chat the
            first fork made and forks nothing; a repeat while the first is at
            work is 409 fork_in_progress; the same key with another body or chat
            is 409 idempotency_key_reused.
          format: uuid
          type: string
        message:
          description: >-
            The new task's first prompt. Omitted, a prompt that says to continue
            the work. Refused beside this_task, whose new chat starts empty.
          minLength: 1
          type: string
        model:
          description: >-
            A model the destination lists for the chat's agent. Omitted, the
            chat's own model where the destination lists it, else the
            destination's default. Refused beside this_task.
          minLength: 1
          type: string
        reasoning_effort:
          description: >-
            A thinking level the destination lists for the model. Omitted, the
            chat's own where the destination lists it for the model, else the
            model's default. Refused beside this_task.
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type: string
        to:
          $ref: '#/components/schemas/ForkDestination'
      type: object
    Chat:
      discriminator:
        mapping:
          awaiting_input: '#/components/schemas/ChatAwaitingInput'
          errored: '#/components/schemas/ChatErrored'
          processing: '#/components/schemas/ChatProcessing'
          queued: '#/components/schemas/ChatQueued'
        propertyName: status
      oneOf:
        - $ref: '#/components/schemas/ChatQueued'
        - $ref: '#/components/schemas/ChatProcessing'
        - $ref: '#/components/schemas/ChatAwaitingInput'
        - $ref: '#/components/schemas/ChatErrored'
    TasksErrorResponse:
      additionalProperties: false
      properties:
        code:
          enum:
            - account_deleting
            - aether_inference_unserved
            - agent_pr_blocked
            - agent_pr_pending
            - agent_profile_changed
            - agent_starts_off
            - agent_uses_own_sign_in
            - answer_on_its_way
            - app_identity_missing
            - attachments_unsupported
            - attribution_unavailable
            - bad_gateway
            - bad_request
            - base_branch_unusable
            - branch_exists
            - caller_inactive
            - chat_archived
            - chat_being_forked
            - chat_moved
            - chat_not_removable
            - chat_settings_fixed
            - chats_not_addable
            - checkout_not_archivable
            - cli_upgrade_required
            - client_outdated
            - computer_cli_outdated
            - computer_starts_no_agents
            - computer_starts_no_forks
            - computer_unreachable
            - conflict
            - connection_creator_only
            - connection_harness_mismatch
            - connection_not_held
            - contents_write_required
            - continuation_failed
            - continuation_unavailable
            - control_forbidden
            - creator_github_access_missing
            - credential_kind_not_admitted
            - credential_named_file
            - detached_head
            - download_unsupported
            - embeddings_unavailable
            - feature_unsupported
            - file_references_unsupported
            - fix_not_requested
            - fix_requests_unrecorded
            - forbidden
            - fork_branch_delete_unsupported
            - fork_forbidden
            - fork_in_progress
            - fork_unsupported
            - gateway_timeout
            - github_claim_unverified
            - github_failed
            - github_identity_mismatch
            - github_identity_required
            - github_push_access_required
            - github_reconnect_required
            - github_ref_not_found
            - gone
            - handed_branch_protected
            - head_moved
            - html_render_nul_byte
            - html_render_too_large
            - idempotency_key_conflict
            - idempotency_key_reused
            - idle_compaction_not_pending
            - idle_compaction_skipped
            - inference_proxy_unavailable
            - insufficient_credits
            - insufficient_inference_balance
            - interaction_mode_unsupported
            - internal_error
            - invalid_request
            - last_queued_message
            - live_protocol_unsupported
            - main_chat_permanent
            - mcp_server_not_connected
            - merge_when_ready_requires_pr_review
            - message_not_queued
            - method_not_allowed
            - mode_forbidden
            - name_follows_session
            - no_checkout_on_computer
            - no_checkpoint_yet
            - no_commit
            - no_dispatch_target
            - no_main_chat
            - no_origin
            - no_turn_running
            - no_work_tree_folder
            - not_acceptable
            - not_found
            - not_implemented
            - onboarding_already_completed
            - onboarding_requirements_missing
            - open_in_terminal
            - org_id_required
            - org_role_insufficient
            - org_suspended
            - payment_required
            - pending_input_answered
            - permission_prompt_answered_in_terminal
            - permission_prompt_expired
            - permission_prompt_open
            - permission_prompt_stopped
            - pr_automation_unsupported
            - pr_review_actor_required
            - pr_review_connection_spent
            - pr_review_publish_forbidden
            - precondition_failed
            - project_archived
            - project_has_no_repository
            - project_repo_disconnected
            - project_repository_differs
            - project_required
            - pull_request_closed
            - pull_request_mirror_failed
            - pull_request_not_mirrored
            - push_failed
            - push_file_too_large
            - push_rejected
            - push_secret_detected
            - question_answers
            - question_shortened
            - queue_for_later_unsupported
            - queued_stop_requires_discard
            - rate_limited
            - reasoning_effort_fixed
            - repository_administration_not_granted
            - repository_already_connected
            - repository_create_forbidden
            - repository_create_rejected
            - repository_created_not_linked
            - repository_not_connected
            - repository_owner_not_caller
            - request_canceled
            - request_expired
            - request_timeout
            - request_too_large
            - review_name_follows_pull_request
            - sandbox_deleted
            - sandbox_failed
            - sandbox_needs_message
            - save_in_progress
            - save_requires_task_creator
            - service_unavailable
            - session_file_missing
            - session_gone
            - session_not_started_by_aether
            - slash_command
            - slash_commands_unsupported
            - stack_cycle
            - stack_too_large
            - stack_two_parents
            - stale_execution
            - stale_or_indeterminate
            - stale_pending_input
            - stream_delivery_gap
            - stream_event_conflict
            - task_already_saved
            - task_archived
            - task_awaiting_message
            - task_awaiting_tool_response
            - task_backed_by_work_tree
            - task_bound_at_creation
            - task_branch_diverged
            - task_branch_is_default
            - task_branch_mismatch
            - task_branch_missing
            - task_connection_disconnected
            - task_creator_deleted
            - task_executing
            - task_file_too_large
            - task_has_no_branch
            - task_has_no_commits
            - task_has_no_files
            - task_has_no_repository
            - task_history_has_merges
            - task_ineligible
            - task_is_child
            - task_not_accepting_messages
            - task_not_pinnable
            - task_not_started
            - task_rebase_in_progress
            - task_settings_changed
            - task_start_failed
            - task_start_pending
            - teleport_unavailable
            - terminal_chat
            - terminal_chat_continuation_refused
            - terminal_chat_run_running
            - terminal_question
            - too_large
            - too_many_live_connections
            - too_many_waiting_messages
            - turn_running
            - unauthenticated
            - unsigned_aether_head
            - unsigned_commit
            - unsupported_changes
            - unsupported_media_type
            - untyped_error
            - user_suspended
            - validation_failed
            - working_tree_dirty
            - workspace_git_unavailable
            - workspace_gone
            - workspace_outdated
            - workspace_rejected
            - workspace_start_failed
          minLength: 1
          type: string
        error:
          minLength: 1
          type: string
        errors:
          items:
            $ref: '#/components/schemas/ErrorDetail'
          type: array
      required:
        - error
        - code
      type: object
    WorkspaceRuntimeAdmissionError:
      additionalProperties: false
      properties:
        code:
          enum:
            - user_suspended
            - org_suspended
            - billing_blocked
            - org_task_concurrency_exceeded
            - credits_exhausted
            - workspace_run_unavailable
          type: string
        error:
          minLength: 1
          type: string
        org_id:
          format: uuid
          type: string
        tier:
          enum:
            - free
            - starter
            - pro
            - max
            - team
          type:
            - string
            - 'null'
        vm_size:
          enum:
            - small
            - medium
            - large
            - xl
          type: string
      required:
        - error
        - code
        - tier
        - vm_size
        - org_id
      type: object
    InferenceBalanceExhaustedErrorResponse:
      additionalProperties: false
      properties:
        code:
          enum:
            - insufficient_inference_balance
          type: string
        error:
          minLength: 1
          type: string
      required:
        - error
        - code
      type: object
    OrgAuthorizationErrorResponse:
      additionalProperties: false
      properties:
        code:
          enum:
            - org_membership_required
            - org_role_insufficient
            - org_suspended
            - account_deleting
            - agent_host_route_not_allowed
            - credential_kind_not_admitted
            - grant_scope_insufficient
          type: string
        error:
          minLength: 1
          type: string
      required:
        - error
        - code
      type: object
    ControlForbiddenErrorResponse:
      additionalProperties: false
      properties:
        code:
          enum:
            - control_forbidden
          type: string
        error:
          minLength: 1
          type: string
      required:
        - error
        - code
      type: object
    McpServerNotConnectedErrorResponse:
      additionalProperties: false
      properties:
        code:
          enum:
            - mcp_server_not_connected
          type: string
        error:
          minLength: 1
          type: string
        servers:
          items:
            $ref: '#/components/schemas/McpServerNotConnected'
          minItems: 1
          type: array
      required:
        - error
        - code
        - servers
      type: object
    ForkDestination:
      description: >-
        Where a fork goes, a union on kind: this_task, a new chat of the chat's
        own task; sandbox, a new task in a cloud sandbox; or computer, a new
        task on one of the caller's own computers. The sandbox and computer
        members are the machine a create takes.
      discriminator:
        mapping:
          computer: '#/components/schemas/StartMachineComputer'
          sandbox: '#/components/schemas/CreateTaskMachineSandbox'
          this_task: '#/components/schemas/ForkThisTaskDestination'
        propertyName: kind
      oneOf:
        - $ref: '#/components/schemas/ForkThisTaskDestination'
        - $ref: '#/components/schemas/CreateTaskMachineSandbox'
        - $ref: '#/components/schemas/StartMachineComputer'
    ChatAwaitingInput:
      additionalProperties: false
      properties:
        agent_session:
          anyOf:
            - $ref: '#/components/schemas/ChatAgentSession'
            - type: 'null'
          description: >-
            The agent's own session behind the chat; null until the agent has
            one. A sandbox chat's was started by Aether, and it has one from the
            moment it has a checkpoint to continue from: it spans its first turn
            to its latest, and until its first turn (a chat forked into its
            task, seeded with its source's checkpoint) both its times are the
            chat's creation.
        agent_type:
          $ref: '#/components/schemas/AgentType'
        archived:
          anyOf:
            - $ref: '#/components/schemas/ChatArchive'
            - type: 'null'
          description: The chat's archive; null while it is not archived.
        awaiting_input:
          $ref: '#/components/schemas/TaskAwaitingInputPayload'
        awaiting_input_kind:
          description: 'awaiting_input''s kind: what the chat awaits.'
          enum:
            - message
            - questions
            - plan
          type: string
        can:
          $ref: '#/components/schemas/ChatAbilities'
        created_at:
          format: date-time
          type: string
        forked_from:
          anyOf:
            - $ref: '#/components/schemas/ChatRef'
            - type: 'null'
          description: >-
            The chat this chat was forked from, in this task or another: it
            started from that chat's checkpoint, under its own harness session,
            and with a copy of its conversation. Null when it is no fork, when
            that chat's task was deleted, or when it is a session another person
            started in their own terminal.
        forks:
          description: >-
            The tasks whose main chat was forked from this chat, newest first,
            at most 20.
          items:
            $ref: '#/components/schemas/TaskForkRef'
          type: array
        id:
          format: uuid
          type: string
        interaction_mode:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type: string
        main:
          description: >-
            Whether this is the task's main chat, the one it was created with,
            which everything addressed to the task reaches. It is never
            archived.
          type: boolean
        model:
          minLength: 1
          type: string
        name:
          description: >-
            The chat's first prompt on one line, cut to 200 characters; null
            before it has one.
          maxLength: 200
          minLength: 1
          type:
            - string
            - 'null'
          x-aether-string-length-unit: unicode-code-point
        notices:
          description: Things the person should know that need no answer.
          items:
            $ref: '#/components/schemas/ChatNotice'
          type: array
        outbox:
          description: >-
            The chat's messages the conversation does not show, oldest first.
            Always empty in a sandbox, whose waiting messages the conversation
            shows as queued turns.
          items:
            $ref: '#/components/schemas/TaskUserMessage'
          type: array
        pending_inputs:
          description: >-
            Every request the chat's agent waits on, oldest first: in a cloud
            sandbox, the question or plan awaiting_input carries; on a person's
            computer, each permission request, question and plan open there,
            none once the chat is archived. Answer each with answerTaskChat, one
            on a computer while its can.answer is available.
          items:
            $ref: '#/components/schemas/PendingInput'
          type: array
        reasoning_effort:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type:
            - string
            - 'null'
        runs_on:
          $ref: '#/components/schemas/ChatRunsOn'
        status:
          enum:
            - awaiting_input
          type: string
        stopping:
          anyOf:
            - $ref: '#/components/schemas/ChatStopping'
            - type: 'null'
          description: >-
            A stop travelling to the chat's computer; null when none is, and
            always in a sandbox.
        task_id:
          format: uuid
          type: string
      required:
        - id
        - task_id
        - name
        - main
        - created_at
        - archived
        - agent_type
        - model
        - reasoning_effort
        - interaction_mode
        - runs_on
        - forked_from
        - can
        - pending_inputs
        - status
        - agent_session
        - outbox
        - stopping
        - forks
        - notices
        - awaiting_input_kind
        - awaiting_input
      type: object
    ChatErrored:
      additionalProperties: false
      properties:
        agent_session:
          anyOf:
            - $ref: '#/components/schemas/ChatAgentSession'
            - type: 'null'
          description: >-
            The agent's own session behind the chat; null until the agent has
            one. A sandbox chat's was started by Aether, and it has one from the
            moment it has a checkpoint to continue from: it spans its first turn
            to its latest, and until its first turn (a chat forked into its
            task, seeded with its source's checkpoint) both its times are the
            chat's creation.
        agent_type:
          $ref: '#/components/schemas/AgentType'
        archived:
          anyOf:
            - $ref: '#/components/schemas/ChatArchive'
            - type: 'null'
          description: The chat's archive; null while it is not archived.
        can:
          $ref: '#/components/schemas/ChatAbilities'
        created_at:
          format: date-time
          type: string
        forked_from:
          anyOf:
            - $ref: '#/components/schemas/ChatRef'
            - type: 'null'
          description: >-
            The chat this chat was forked from, in this task or another: it
            started from that chat's checkpoint, under its own harness session,
            and with a copy of its conversation. Null when it is no fork, when
            that chat's task was deleted, or when it is a session another person
            started in their own terminal.
        forks:
          description: >-
            The tasks whose main chat was forked from this chat, newest first,
            at most 20.
          items:
            $ref: '#/components/schemas/TaskForkRef'
          type: array
        id:
          format: uuid
          type: string
        interaction_mode:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type: string
        main:
          description: >-
            Whether this is the task's main chat, the one it was created with,
            which everything addressed to the task reaches. It is never
            archived.
          type: boolean
        model:
          minLength: 1
          type: string
        name:
          description: >-
            The chat's first prompt on one line, cut to 200 characters; null
            before it has one.
          maxLength: 200
          minLength: 1
          type:
            - string
            - 'null'
          x-aether-string-length-unit: unicode-code-point
        notices:
          description: Things the person should know that need no answer.
          items:
            $ref: '#/components/schemas/ChatNotice'
          type: array
        outbox:
          description: >-
            The chat's messages the conversation does not show, oldest first.
            Always empty in a sandbox, whose waiting messages the conversation
            shows as queued turns.
          items:
            $ref: '#/components/schemas/TaskUserMessage'
          type: array
        pending_inputs:
          description: >-
            Every request the chat's agent waits on, oldest first: in a cloud
            sandbox, the question or plan awaiting_input carries; on a person's
            computer, each permission request, question and plan open there,
            none once the chat is archived. Answer each with answerTaskChat, one
            on a computer while its can.answer is available.
          items:
            $ref: '#/components/schemas/PendingInput'
          type: array
        reasoning_effort:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type:
            - string
            - 'null'
        runs_on:
          $ref: '#/components/schemas/ChatRunsOn'
        status:
          enum:
            - errored
          type: string
        stopping:
          anyOf:
            - $ref: '#/components/schemas/ChatStopping'
            - type: 'null'
          description: >-
            A stop travelling to the chat's computer; null when none is, and
            always in a sandbox.
        task_id:
          format: uuid
          type: string
      required:
        - id
        - task_id
        - name
        - main
        - created_at
        - archived
        - agent_type
        - model
        - reasoning_effort
        - interaction_mode
        - runs_on
        - forked_from
        - can
        - pending_inputs
        - status
        - agent_session
        - outbox
        - stopping
        - forks
        - notices
      type: object
    ChatProcessing:
      additionalProperties: false
      properties:
        agent_session:
          anyOf:
            - $ref: '#/components/schemas/ChatAgentSession'
            - type: 'null'
          description: >-
            The agent's own session behind the chat; null until the agent has
            one. A sandbox chat's was started by Aether, and it has one from the
            moment it has a checkpoint to continue from: it spans its first turn
            to its latest, and until its first turn (a chat forked into its
            task, seeded with its source's checkpoint) both its times are the
            chat's creation.
        agent_type:
          $ref: '#/components/schemas/AgentType'
        archived:
          anyOf:
            - $ref: '#/components/schemas/ChatArchive'
            - type: 'null'
          description: The chat's archive; null while it is not archived.
        can:
          $ref: '#/components/schemas/ChatAbilities'
        created_at:
          format: date-time
          type: string
        forked_from:
          anyOf:
            - $ref: '#/components/schemas/ChatRef'
            - type: 'null'
          description: >-
            The chat this chat was forked from, in this task or another: it
            started from that chat's checkpoint, under its own harness session,
            and with a copy of its conversation. Null when it is no fork, when
            that chat's task was deleted, or when it is a session another person
            started in their own terminal.
        forks:
          description: >-
            The tasks whose main chat was forked from this chat, newest first,
            at most 20.
          items:
            $ref: '#/components/schemas/TaskForkRef'
          type: array
        id:
          format: uuid
          type: string
        interaction_mode:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type: string
        main:
          description: >-
            Whether this is the task's main chat, the one it was created with,
            which everything addressed to the task reaches. It is never
            archived.
          type: boolean
        model:
          minLength: 1
          type: string
        name:
          description: >-
            The chat's first prompt on one line, cut to 200 characters; null
            before it has one.
          maxLength: 200
          minLength: 1
          type:
            - string
            - 'null'
          x-aether-string-length-unit: unicode-code-point
        notices:
          description: Things the person should know that need no answer.
          items:
            $ref: '#/components/schemas/ChatNotice'
          type: array
        outbox:
          description: >-
            The chat's messages the conversation does not show, oldest first.
            Always empty in a sandbox, whose waiting messages the conversation
            shows as queued turns.
          items:
            $ref: '#/components/schemas/TaskUserMessage'
          type: array
        pending_inputs:
          description: >-
            Every request the chat's agent waits on, oldest first: in a cloud
            sandbox, the question or plan awaiting_input carries; on a person's
            computer, each permission request, question and plan open there,
            none once the chat is archived. Answer each with answerTaskChat, one
            on a computer while its can.answer is available.
          items:
            $ref: '#/components/schemas/PendingInput'
          type: array
        reasoning_effort:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type:
            - string
            - 'null'
        runs_on:
          $ref: '#/components/schemas/ChatRunsOn'
        status:
          enum:
            - processing
          type: string
        stopping:
          anyOf:
            - $ref: '#/components/schemas/ChatStopping'
            - type: 'null'
          description: >-
            A stop travelling to the chat's computer; null when none is, and
            always in a sandbox.
        task_id:
          format: uuid
          type: string
      required:
        - id
        - task_id
        - name
        - main
        - created_at
        - archived
        - agent_type
        - model
        - reasoning_effort
        - interaction_mode
        - runs_on
        - forked_from
        - can
        - pending_inputs
        - status
        - agent_session
        - outbox
        - stopping
        - forks
        - notices
      type: object
    ChatQueued:
      additionalProperties: false
      properties:
        agent_session:
          anyOf:
            - $ref: '#/components/schemas/ChatAgentSession'
            - type: 'null'
          description: >-
            The agent's own session behind the chat; null until the agent has
            one. A sandbox chat's was started by Aether, and it has one from the
            moment it has a checkpoint to continue from: it spans its first turn
            to its latest, and until its first turn (a chat forked into its
            task, seeded with its source's checkpoint) both its times are the
            chat's creation.
        agent_type:
          $ref: '#/components/schemas/AgentType'
        archived:
          anyOf:
            - $ref: '#/components/schemas/ChatArchive'
            - type: 'null'
          description: The chat's archive; null while it is not archived.
        can:
          $ref: '#/components/schemas/ChatAbilities'
        created_at:
          format: date-time
          type: string
        forked_from:
          anyOf:
            - $ref: '#/components/schemas/ChatRef'
            - type: 'null'
          description: >-
            The chat this chat was forked from, in this task or another: it
            started from that chat's checkpoint, under its own harness session,
            and with a copy of its conversation. Null when it is no fork, when
            that chat's task was deleted, or when it is a session another person
            started in their own terminal.
        forks:
          description: >-
            The tasks whose main chat was forked from this chat, newest first,
            at most 20.
          items:
            $ref: '#/components/schemas/TaskForkRef'
          type: array
        id:
          format: uuid
          type: string
        interaction_mode:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type: string
        main:
          description: >-
            Whether this is the task's main chat, the one it was created with,
            which everything addressed to the task reaches. It is never
            archived.
          type: boolean
        model:
          minLength: 1
          type: string
        name:
          description: >-
            The chat's first prompt on one line, cut to 200 characters; null
            before it has one.
          maxLength: 200
          minLength: 1
          type:
            - string
            - 'null'
          x-aether-string-length-unit: unicode-code-point
        notices:
          description: Things the person should know that need no answer.
          items:
            $ref: '#/components/schemas/ChatNotice'
          type: array
        outbox:
          description: >-
            The chat's messages the conversation does not show, oldest first.
            Always empty in a sandbox, whose waiting messages the conversation
            shows as queued turns.
          items:
            $ref: '#/components/schemas/TaskUserMessage'
          type: array
        pending_inputs:
          description: >-
            Every request the chat's agent waits on, oldest first: in a cloud
            sandbox, the question or plan awaiting_input carries; on a person's
            computer, each permission request, question and plan open there,
            none once the chat is archived. Answer each with answerTaskChat, one
            on a computer while its can.answer is available.
          items:
            $ref: '#/components/schemas/PendingInput'
          type: array
        reasoning_effort:
          pattern: ^[a-z][a-z0-9_]{0,31}$
          type:
            - string
            - 'null'
        runs_on:
          $ref: '#/components/schemas/ChatRunsOn'
        status:
          enum:
            - queued
          type: string
        stopping:
          anyOf:
            - $ref: '#/components/schemas/ChatStopping'
            - type: 'null'
          description: >-
            A stop travelling to the chat's computer; null when none is, and
            always in a sandbox.
        task_id:
          format: uuid
          type: string
        waiting:
          $ref: '#/components/schemas/ChatWaiting'
        waits_for:
          anyOf:
            - $ref: '#/components/schemas/ChatTurnRef'
            - type: 'null'
          description: >-
            The turn another chat of the task runs while this chat's queue
            waits: one turn runs at a time per workspace. Set exactly when
            waiting's code is other_chat_turn.
      required:
        - id
        - task_id
        - name
        - main
        - created_at
        - archived
        - agent_type
        - model
        - reasoning_effort
        - interaction_mode
        - runs_on
        - forked_from
        - can
        - pending_inputs
        - status
        - agent_session
        - outbox
        - stopping
        - forks
        - notices
        - waits_for
        - waiting
      type: object
    ErrorDetail:
      additionalProperties: false
      properties:
        location:
          description: >-
            Where the error occurred, e.g. 'body.items[3].tags' or
            'path.thing-id'
          type: string
        message:
          description: Error message text
          type: string
        value:
          description: The value at the given location
      type: object
    McpServerNotConnected:
      additionalProperties: false
      properties:
        display_name:
          type: string
        key:
          type: string
        policy:
          enum:
            - creator
            - org
          type: string
        reason:
          enum:
            - not_connected
            - needs_reauth
          type: string
        repo:
          $ref: '#/components/schemas/McpServerRepoDeclaration'
      required:
        - key
        - display_name
        - policy
        - reason
      type: object
    StartMachineComputer:
      additionalProperties: false
      description: One of the caller's own computers.
      properties:
        computer_id:
          format: uuid
          type: string
        kind:
          enum:
            - computer
          type: string
      required:
        - kind
        - computer_id
      type: object
    CreateTaskMachineSandbox:
      additionalProperties: false
      description: A cloud sandbox Aether runs, with its size.
      properties:
        kind:
          enum:
            - sandbox
          type: string
        vm_size:
          description: The sandbox's size. Omitted, the project's default size.
          enum:
            - medium
            - large
            - xl
          type: string
      required:
        - kind
      type: object
    ForkThisTaskDestination:
      additionalProperties: false
      description: >-
        A new chat of the chat's own task: the same files, branch and pull
        request.
      properties:
        kind:
          enum:
            - this_task
          type: string
      required:
        - kind
      type: object
    ChatAgentSession:
      additionalProperties: false
      description: >-
        The agent's own session behind the chat, for display: what the chat can
        do is its can.
      properties:
        last_active_at:
          format: date-time
          type: string
        open_in:
          additionalProperties: false
          description: >-
            Where the session is open: terminal; null when it is open nowhere
            Aether knows of.
          properties:
            code:
              enum:
                - terminal
              type: string
            label:
              minLength: 1
              type: string
          required:
            - code
            - label
          type:
            - object
            - 'null'
        resume_command:
          description: >-
            The command that continues the session in a terminal, as its reader
            runs it. For a sandbox chat, `aether task chats continue` on the
            reader's own computer; for a chat on a computer, `aether resume` on
            that computer, for its person alone. Null when there is no command
            this reader could ever run for this chat as it stands; a command
            that is sent may still be refused while a turn runs, with its
            reason.
          minLength: 1
          type:
            - string
            - 'null'
        resume_hint:
          description: >-
            One sentence saying where and how to run resume_command, which a
            client shows beside the command as written. Non-null exactly when
            resume_command is.
          minLength: 1
          type:
            - string
            - 'null'
        session_id:
          description: >-
            The agent's own id of the session on the person's computer, which
            its resume flag takes; null in a sandbox.
          minLength: 1
          type:
            - string
            - 'null'
        started_at:
          format: date-time
          type: string
        started_by:
          additionalProperties: false
          description: 'Who started the session: aether, or person, in their own terminal.'
          properties:
            code:
              enum:
                - aether
                - person
              type: string
            label:
              minLength: 1
              type: string
          required:
            - code
            - label
          type: object
      required:
        - started_by
        - open_in
        - started_at
        - last_active_at
        - session_id
        - resume_command
        - resume_hint
      type: object
    AgentType:
      description: >-
        The agent harness that runs a task, a profile or a connection:
        claude-code or claude_code is Claude Code, codex is Codex, opencode is
        OpenCode.
      enum:
        - codex
        - claude-code
        - opencode
        - claude_code
      type: string
    ChatArchive:
      additionalProperties: false
      properties:
        archived_at:
          format: date-time
          type: string
        stopped_turn_id:
          description: >-
            The turn of the chat its archive stopped first; null when no turn of
            the chat was running.
          format: uuid
          type:
            - string
            - 'null'
      required:
        - archived_at
        - stopped_turn_id
      type: object
    TaskAwaitingInputPayload:
      discriminator:
        mapping:
          message: '#/components/schemas/TaskAwaitingInputMessage'
          plan: '#/components/schemas/TaskAwaitingInputPlan'
          questions: '#/components/schemas/TaskAwaitingInputQuestions'
        propertyName: kind
      oneOf:
        - $ref: '#/components/schemas/TaskAwaitingInputMessage'
        - $ref: '#/components/schemas/TaskAwaitingInputQuestions'
        - $ref: '#/components/schemas/TaskAwaitingInputPlan'
    ChatAbilities:
      additionalProperties: false
      description: >-
        What the caller can do with the chat as things stand, each ability
        computed for them: send, sending it a message; compose, what the message
        may carry; steer, whether a message sent while a turn runs joins that
        turn, which says what a send would do whether or not a turn runs now;
        queue_for_later, a message that waits for the running turn to end; stop,
        stopping its turn; archive, archiving it and restoring it; remove,
        removing it; fork, forking it.
      properties:
        archive:
          $ref: '#/components/schemas/Ability'
        compose:
          $ref: '#/components/schemas/ComposeAbilities'
        fork:
          $ref: '#/components/schemas/Ability'
        queue_for_later:
          $ref: '#/components/schemas/Ability'
        remove:
          $ref: '#/components/schemas/Ability'
        send:
          $ref: '#/components/schemas/Ability'
        steer:
          $ref: '#/components/schemas/Ability'
        stop:
          $ref: '#/components/schemas/Ability'
      required:
        - archive
        - compose
        - fork
        - queue_for_later
        - remove
        - send
        - steer
        - stop
      type: object
    ChatRef:
      additionalProperties: false
      description: One chat of one task.
      properties:
        chat_id:
          format: uuid
          type: string
        task_id:
          format: uuid
          type: string
      required:
        - task_id
        - chat_id
      type: object
    TaskForkRef:
      additionalProperties: false
      description: A task whose main chat was forked from the chat.
      properties:
        created_at:
          description: When the task was created.
          format: date-time
          type: string
        name:
          description: The task's name.
          type: string
        task_id:
          format: uuid
          type: string
      required:
        - task_id
        - name
        - created_at
      type: object
    ChatNotice:
      additionalProperties: false
      description: >-
        Something the person should know that needs no answer. Every notice is
        shown alike, as plain text, until expires_at.
      properties:
        code:
          enum:
            - answer_not_used
            - request_expired
            - stop_settled
            - stop_undelivered
            - run_failed
            - session_gone
            - record_unreadable
          type: string
        expires_at:
          description: When the notice stops being shown; null while the chat exists.
          format: date-time
          type:
            - string
            - 'null'
        message:
          minLength: 1
          type: string
        since:
          format: date-time
          type: string
        tool_id:
          description: The request the notice is about.
          minLength: 1
          type: string
      required:
        - code
        - message
        - since
        - expires_at
      type: object
    TaskUserMessage:
      discriminator:
        mapping:
          accepted: '#/components/schemas/TaskUserMessageAccepted'
          done: '#/components/schemas/TaskUserMessageDone'
          not_delivered: '#/components/schemas/TaskUserMessageNotDelivered'
          processing: '#/components/schemas/TaskUserMessageProcessing'
          queued: '#/components/schemas/TaskUserMessageQueued'
          sent: '#/components/schemas/TaskUserMessageSent'
          unknown: '#/components/schemas/TaskUserMessageUnknown'
        propertyName: state
      oneOf:
        - $ref: '#/components/schemas/TaskUserMessageQueued'
        - $ref: '#/components/schemas/TaskUserMessageSent'
        - $ref: '#/components/schemas/TaskUserMessageAccepted'
        - $ref: '#/components/schemas/TaskUserMessageProcessing'
        - $ref: '#/components/schemas/TaskUserMessageDone'
        - $ref: '#/components/schemas/TaskUserMessageNotDelivered'
        - $ref: '#/components/schemas/TaskUserMessageUnknown'
    PendingInput:
      discriminator:
        mapping:
          permission: '#/components/schemas/PendingInputPermission'
          plan: '#/components/schemas/PendingInputPlan'
          questions: '#/components/schemas/PendingInputQuestions'
        propertyName: kind
      oneOf:
        - $ref: '#/components/schemas/PendingInputPlan'
        - $ref: '#/components/schemas/PendingInputQuestions'
        - $ref: '#/components/schemas/PendingInputPermission'
    ChatRunsOn:
      discriminator:
        mapping:
          aether: '#/components/schemas/TaskRunsOnAether'
          disconnected: '#/components/schemas/TaskRunsOnDisconnected'
          own_sign_in: '#/components/schemas/ChatRunsOnOwnSignIn'
          stored: '#/components/schemas/TaskRunsOnStored'
        propertyName: runs_on
      oneOf:
        - $ref: '#/components/schemas/TaskRunsOnAether'
        - $ref: '#/components/schemas/TaskRunsOnStored'
        - $ref: '#/components/schemas/TaskRunsOnDisconnected'
        - $ref: '#/components/schemas/ChatRunsOnOwnSignIn'
    ChatStopping:
      additionalProperties: false
      description: A stop travelling to the chat's computer, and when it was asked for.
      properties:
        requested_at:
          format: date-time
          type: string
      required:
        - requested_at
      type: object
    ChatWaiting:
      additionalProperties: false
      description: >-
        Why the chat's oldest waiting message has not started. other_chat_turn:
        another chat's turn runs, which waits_for names. On a computer:
        task_start_pending while the task's start there is pending; turn_running
        while the chat's own turn runs; earlier_message while an earlier message
        of the chat is on its way; computer_unreachable while the computer
        cannot be reached; chat_being_forked while the chat's work is being
        handed to a fork; open_in_terminal, agent_starts_off, agent_limit,
        chat_busy, not_signed_in or agent_not_installed while the computer holds
        its run back for that reason; on_its_way once it is handed to the
        computer, which has not reported on it; with_agent once the agent has it
        and has not started it. In a sandbox: sandbox_not_ready while the task's
        sandbox is starting, resuming, stopping or preparing; billing_blocked,
        org_task_concurrency_exceeded, credits_exhausted or
        workspace_run_unavailable while the account's standing keeps the sandbox
        from starting, with the standing's own sentence; provider_overloaded
        while a turn waits to be retried; earlier_message while the task runs
        another chat's message first (the task's order, not the chat's);
        on_its_way while it is on its way to the agent.
      properties:
        code:
          enum:
            - turn_running
            - other_chat_turn
            - task_start_pending
            - earlier_message
            - computer_unreachable
            - chat_being_forked
            - open_in_terminal
            - agent_starts_off
            - agent_limit
            - chat_busy
            - not_signed_in
            - agent_not_installed
            - on_its_way
            - with_agent
            - sandbox_not_ready
            - provider_overloaded
            - billing_blocked
            - org_task_concurrency_exceeded
            - credits_exhausted
            - workspace_run_unavailable
          type: string
        message:
          minLength: 1
          type: string
      required:
        - code
        - message
      type: object
    ChatTurnRef:
      additionalProperties: false
      description: >-
        One turn of one chat of a task. A queued message or chat names the turn
        another chat of its task runs: one turn runs at a time per workspace, so
        it runs after that turn.
      properties:
        chat_id:
          format: uuid
          type: string
        turn_id:
          format: uuid
          type: string
      required:
        - chat_id
        - turn_id
      type: object
    McpServerRepoDeclaration:
      additionalProperties: false
      properties:
        cataloged:
          type: boolean
        file:
          enum:
            - .mcp.json
            - .codex/config.toml
          type: string
      required:
        - file
        - cataloged
      type: object
    TaskAwaitingInputMessage:
      additionalProperties: false
      properties:
        idle_compaction:
          $ref: '#/components/schemas/TaskIdleCompaction'
        kind:
          enum:
            - message
          type: string
      required:
        - kind
      type: object
    TaskAwaitingInputPlan:
      additionalProperties: false
      properties:
        input:
          $ref: '#/components/schemas/ProposePlanToolInput'
        kind:
          enum:
            - plan
          type: string
        tool_id:
          minLength: 1
          type: string
      required:
        - kind
        - tool_id
        - input
      type: object
    TaskAwaitingInputQuestions:
      additionalProperties: false
      properties:
        input:
          $ref: '#/components/schemas/AskUserToolInput'
        kind:
          enum:
            - questions
          type: string
        tool_id:
          minLength: 1
          type: string
      required:
        - kind
        - tool_id
        - input
      type: object
    Ability:
      discriminator:
        mapping:
          available: '#/components/schemas/AbilityAvailable'
          not_now: '#/components/schemas/AbilityNotNow'
          not_permitted: '#/components/schemas/AbilityNotPermitted'
          unsupported: '#/components/schemas/AbilityUnsupported'
        propertyName: availability
      oneOf:
        - $ref: '#/components/schemas/AbilityAvailable'
        - $ref: '#/components/schemas/AbilityNotNow'
        - $ref: '#/components/schemas/AbilityUnsupported'
        - $ref: '#/components/schemas/AbilityNotPermitted'
    ComposeAbilities:
      additionalProperties: false
      description: >-
        What a message to a chat, or a new chat, may carry: attach, files
        attached to a message; reference_files, files of the repository a
        message references; use_slash_commands, a message that starts with /;
        change_model, the chat's model; change_reasoning_effort, its thinking
        level; change_interaction_mode, its mode; change_connection, the
        inference account it runs on.
      properties:
        attach:
          $ref: '#/components/schemas/Ability'
        change_connection:
          $ref: '#/components/schemas/Ability'
        change_interaction_mode:
          $ref: '#/components/schemas/Ability'
        change_model:
          $ref: '#/components/schemas/Ability'
        change_reasoning_effort:
          $ref: '#/components/schemas/Ability'
        reference_files:
          $ref: '#/components/schemas/Ability'
        use_slash_commands:
          $ref: '#/components/schemas/Ability'
      required:
        - attach
        - change_connection
        - change_interaction_mode
        - change_model
        - change_reasoning_effort
        - reference_files
        - use_slash_commands
      type: object
    TaskUserMessageAccepted:
      additionalProperties: false
      description: >-
        Taken into a running turn without being its root: admitted as live
        input, or bundled with the root.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        message_event:
          $ref: '#/components/schemas/TimelineMessageEventCard'
        sender:
          $ref: '#/components/schemas/TaskPerson'
        sequence:
          description: >-
            The message's place in the conversation; null until a turn has
            delivered it.
          format: int64
          maximum: 9007199254740991
          minimum: 0
          type:
            - integer
            - 'null'
        state:
          enum:
            - accepted
          type: string
        text:
          type: string
        tool_response:
          discriminator:
            mapping:
              ask_user: '#/components/schemas/AskUserToolResponse'
              propose_plan: '#/components/schemas/ProposePlanToolResponse'
            propertyName: tool_name
          oneOf:
            - $ref: '#/components/schemas/AskUserToolResponse'
            - $ref: '#/components/schemas/ProposePlanToolResponse'
        turn_id:
          description: >-
            The conversation turn the message is part of; null while it is
            queued.
          format: uuid
          type:
            - string
            - 'null'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
      type: object
    TaskUserMessageDone:
      additionalProperties: false
      description: Delivered, and its turn ended.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        message_event:
          $ref: '#/components/schemas/TimelineMessageEventCard'
        sender:
          $ref: '#/components/schemas/TaskPerson'
        sequence:
          description: >-
            The message's place in the conversation; null until a turn has
            delivered it.
          format: int64
          maximum: 9007199254740991
          minimum: 0
          type:
            - integer
            - 'null'
        state:
          enum:
            - done
          type: string
        text:
          type: string
        tool_response:
          discriminator:
            mapping:
              ask_user: '#/components/schemas/AskUserToolResponse'
              propose_plan: '#/components/schemas/ProposePlanToolResponse'
            propertyName: tool_name
          oneOf:
            - $ref: '#/components/schemas/AskUserToolResponse'
            - $ref: '#/components/schemas/ProposePlanToolResponse'
        turn_id:
          description: >-
            The conversation turn the message is part of; null while it is
            queued.
          format: uuid
          type:
            - string
            - 'null'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
      type: object
    TaskUserMessageNotDelivered:
      additionalProperties: false
      description: >-
        The message never reached the agent. Sending it again, as a new message,
        is safe.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        failure:
          $ref: '#/components/schemas/MessageFailure'
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        meaning:
          description: >-
            What the message's state means for the person, and whether sending
            it again is safe: the sentence to show beside it.
          minLength: 1
          type: string
        sequence:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        state:
          enum:
            - not_delivered
          type: string
        text:
          type: string
        turn_id:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
        - failure
        - meaning
      type: object
    TaskUserMessageProcessing:
      additionalProperties: false
      description: The root of the turn running now.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        message_event:
          $ref: '#/components/schemas/TimelineMessageEventCard'
        sender:
          $ref: '#/components/schemas/TaskPerson'
        sequence:
          description: >-
            The message's place in the conversation; null until a turn has
            delivered it.
          format: int64
          maximum: 9007199254740991
          minimum: 0
          type:
            - integer
            - 'null'
        state:
          enum:
            - processing
          type: string
        text:
          type: string
        tool_response:
          discriminator:
            mapping:
              ask_user: '#/components/schemas/AskUserToolResponse'
              propose_plan: '#/components/schemas/ProposePlanToolResponse'
            propertyName: tool_name
          oneOf:
            - $ref: '#/components/schemas/AskUserToolResponse'
            - $ref: '#/components/schemas/ProposePlanToolResponse'
        turn_id:
          description: >-
            The conversation turn the message is part of; null while it is
            queued.
          format: uuid
          type:
            - string
            - 'null'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
      type: object
    TaskUserMessageQueued:
      additionalProperties: false
      description: Aether holds the message, and it can be taken back.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        expires_at:
          description: >-
            When Aether stops holding the message, which then reads
            not_delivered with hold_expired; null in a cloud sandbox.
          format: date-time
          type:
            - string
            - 'null'
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        message_event:
          $ref: '#/components/schemas/TimelineMessageEventCard'
        sender:
          $ref: '#/components/schemas/TaskPerson'
        sequence:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        state:
          enum:
            - queued
          type: string
        text:
          type: string
        tool_response:
          discriminator:
            mapping:
              ask_user: '#/components/schemas/AskUserToolResponse'
              propose_plan: '#/components/schemas/ProposePlanToolResponse'
            propertyName: tool_name
          oneOf:
            - $ref: '#/components/schemas/AskUserToolResponse'
            - $ref: '#/components/schemas/ProposePlanToolResponse'
        turn_id:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        waiting:
          $ref: '#/components/schemas/QueuedMessageWaiting'
        waits_for:
          $ref: '#/components/schemas/ChatTurnRef'
          description: >-
            The turn another chat of the task runs while the message waits: one
            turn runs at a time per workspace. Present exactly when waiting's
            code is other_chat_turn.
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
        - waiting
        - expires_at
      type: object
    TaskUserMessageSent:
      additionalProperties: false
      description: The message left Aether, and the agent's record does not show it yet.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        sequence:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        state:
          enum:
            - sent
          type: string
        text:
          type: string
        turn_id:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        waiting:
          $ref: '#/components/schemas/SentMessageWaiting'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
        - waiting
      type: object
    TaskUserMessageUnknown:
      additionalProperties: false
      description: >-
        The message may have reached the agent, and the agent's record did not
        show it in time. Aether never sends it again.
      properties:
        attachments:
          items:
            $ref: '#/components/schemas/ConversationAttachment'
          type: array
        client_message_id:
          format: uuid
          type: string
        created_at:
          format: date-time
          type: string
        id:
          description: >-
            A task message's id: a uuid for a message the API queued or a chat
            forked inside its task copied, or a key derived from the message's
            source (an assistant message, a seam, a message replayed from an
            imported session).
          pattern: >-
            ^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|message:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9a-f]{64}|implicit:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:(?:text|thinking):[0-9]+|seam:compaction:[^:]+:[^:]+|seam:teleport:\S(?:[\s\S]*\S)?|teleport:\S(?:[\s\S]*\S)?:[0-9]{6,})$
          type: string
        kind:
          enum:
            - user
          type: string
        meaning:
          description: >-
            What the message's state means for the person, and whether sending
            it again is safe: the sentence to show beside it.
          minLength: 1
          type: string
        sequence:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
        state:
          enum:
            - unknown
          type: string
        text:
          type: string
        turn_id:
          description: 'Null: the conversation does not show the message.'
          type: 'null'
      required:
        - kind
        - id
        - turn_id
        - sequence
        - state
        - text
        - attachments
        - created_at
        - meaning
      type: object
    PendingInputPermission:
      additionalProperties: false
      description: The agent waits to be allowed one tool call. No cloud sandbox asks this.
      properties:
        answer:
          anyOf:
            - $ref: '#/components/schemas/PendingInputAnswerPermission'
            - type: 'null'
          description: >-
            The answer from Aether, of the request's kind, while it travels to
            the agent; null until then, and null for a denial of questions,
            which their answer cannot carry: can.answer reads answer_on_its_way
            while any answer travels. A cloud sandbox's request leaves the list
            once answered, so its answer is always null.
        can:
          $ref: '#/components/schemas/PendingInputAbilities'
        command:
          description: The command the tool would run, null when it runs none.
          type:
            - string
            - 'null'
        decisions:
          description: The decisions a person may take, each a button.
          items:
            $ref: '#/components/schemas/PendingInputDecision'
          minItems: 1
          type: array
        expires_at:
          description: >-
            When the request lapses unanswered; null when it never does, as in a
            cloud sandbox.
          format: date-time
          type:
            - string
            - 'null'
        input_shortened:
          description: Whether the input was cut to fit; always false in a cloud sandbox.
          type: boolean
        kind:
          enum:
            - permission
          type: string
        requested_at:
          description: When the agent asked.
          format: date-time
          type: string
        tool_id:
          description: Names the request in its answer.
          maxLength: 128
          minLength: 1
          pattern: ^[A-Za-z0-9_-]{1,128}$
          type: string
        tool_input:
          additionalProperties: true
          description: The tool call's input.
          properties: {}
          type: object
        tool_name:
          description: The tool the agent would call.
          minLength: 1
          type: string
      required:
        - answer
        - can
        - command
        - decisions
        - expires_at
        - input_shortened
        - kind
        - requested_at
        - tool_id
        - tool_input
        - tool_name
      type: object
    PendingInputPlan:
      additionalProperties: false
      description: The agent proposed a plan and waits for it to be approved or sent back.
      properties:
        answer:
          anyOf:
            - $ref: '#/components/schemas/PendingInputAnswerPlan'
            - type: 'null'
          description: >-
            The answer from Aether, of the request's kind, while it travels to
            the agent; null until then, and null for a denial of questions,
            which their answer cannot carry: can.answer reads answer_on_its_way
            while any answer travels. A cloud sandbox's request leaves the list
            once answered, so its answer is always null.
        can:
          $ref: '#/components/schemas/PendingInputAbilities'
        decisions:
          description: The decisions a person may take, each a button.
          items:
            $ref: '#/components/schemas/PendingInputDecision'
          minItems: 1
          type: array
        expires_at:
          description: >-
            When the request lapses unanswered; null when it never does, as in a
            cloud sandbox.
          format: date-time
          type:
            - string
            - 'null'
        input:
          $ref: '#/components/schemas/ProposePlanToolInput'
        kind:
          enum:
            - plan
          type: string
        requested_at:
          description: When the agent asked.
          format: date-time
          type: string
        tool_id:
          description: Names the request in its answer.
          maxLength: 128
          minLength: 1
          pattern: ^[A-Za-z0-9_-]{1,128}$
          type: string
      required:
        - answer
        - can
        - decisions
        - expires_at
        - input
        - kind
        - requested_at
        - tool_id
      type: object
    PendingInputQuestions:
      additionalProperties: false
      description: The agent asked questions and waits for their answers.
      properties:
        answer:
          anyOf:
            - $ref: '#/components/schemas/PendingInputAnswerQuestions'
            - type: 'null'
          description: >-
            The answer from Aether, of the request's kind, while it travels to
            the agent; null until then, and null for a denial of questions,
            which their answer cannot carry: can.answer reads answer_on_its_way
            while any answer travels. A cloud sandbox's request leaves the list
            once answered, so its answer is always null.
        can:
          $ref: '#/components/schemas/PendingInputAbilities'
        decisions:
          description: >-
            The decisions that answer the questions in place of their answers,
            each a button: present where they may be declined from Aether, a
            turn Aether started on a computer, whose questions are dismissed.
            Absent elsewhere.
          items:
            $ref: '#/components/schemas/PendingInputDecision'
          minItems: 1
          type: array
        expires_at:
          description: >-
            When the request lapses unanswered; null when it never does, as in a
            cloud sandbox.
          format: date-time
          type:
            - string
            - 'null'
        input:
          $ref: '#/components/schemas/AskUserToolInput'
        input_shortened:
          description: Whether the input was cut to fit; always false in a cloud sandbox.
          type: boolean
        kind:
          enum:
            - questions
          type: string
        requested_at:
          description: When the agent asked.
          format: date-time
          type: string
        tool_id:
          description: Names the request in its answer.
          maxLength: 128
          minLength: 1
          pattern: ^[A-Za-z0-9_-]{1,128}$
          type: string
      required:
        - answer
        - can
        - expires_at
        - input
        - input_shortened
        - kind
        - requested_at
        - tool_id
      type: object
    TaskRunsOnAether:
      additionalProperties: false
      properties:
        runs_on:
          enum:
            - aether
          type: string
      required:
        - runs_on
      type: object
    TaskRunsOnDisconnected:
      additionalProperties: false
      properties:
        runs_on:
          enum:
            - disconnected
          type: string
      required:
        - runs_on
      type: object
    ChatRunsOnOwnSignIn:
      additionalProperties: false
      description: 'A chat on its person''s computer: its agent uses their own sign-in there.'
      properties:
        runs_on:
          enum:
            - own_sign_in
          type: string
      required:
        - runs_on
      type: object
    TaskRunsOnStored:
      additionalProperties: false
      properties:
        id:
          format: uuid
          type: string
        name:
          minLength: 1
          type: string
        option:
          enum:
            - claude_plan
            - anthropic_api_key
            - chatgpt_plan
            - openai_api_key
            - openrouter_api_key
            - opencode_auth_file
          type: string
        runs_on:
          enum:
            - stored
          type: string
      required:
        - runs_on
        - id
        - option
        - name
      type: object
    TaskIdleCompaction:
      additionalProperties: false
      description: >-
        Present while Aether will compact the waiting task's idle conversation:
        at fires_at, just before the prompt cache of the turn that left it idle
        at idle_since expires, it replaces the context_tokens-token conversation
        with a summary. Absent when none is scheduled, a newer turn superseded
        it, the person kept the full context (keepTaskFullContext), or it fired
        or was skipped.
      properties:
        context_tokens:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        fires_at:
          format: date-time
          type: string
        idle_since:
          format: date-time
          type: string
      required:
        - idle_since
        - fires_at
        - context_tokens
      type: object
    ProposePlanToolInput:
      additionalProperties: true
      properties:
        plan:
          type: string
        summary:
          type: string
      required:
        - summary
        - plan
      type: object
    AskUserToolInput:
      additionalProperties: true
      properties:
        questions:
          items:
            $ref: '#/components/schemas/AskUserQuestion'
          minItems: 1
          type: array
      required:
        - questions
      type: object
    AbilityAvailable:
      additionalProperties: false
      description: The action will be carried out.
      properties:
        availability:
          enum:
            - available
          type: string
        notes:
          description: >-
            What a person reads before taking the action; empty when there is
            nothing to note.
          items:
            $ref: '#/components/schemas/AbilityMessage'
          type: array
      required:
        - availability
        - notes
      type: object
    AbilityNotNow:
      additionalProperties: false
      description: The action is possible for this chat or task, but not as things stand.
      properties:
        availability:
          enum:
            - not_now
          type: string
        reason:
          $ref: '#/components/schemas/AbilityMessage'
      required:
        - availability
        - reason
      type: object
    AbilityNotPermitted:
      additionalProperties: false
      description: The caller may not take the action.
      properties:
        availability:
          enum:
            - not_permitted
          type: string
        reason:
          $ref: '#/components/schemas/AbilityMessage'
      required:
        - availability
        - reason
      type: object
    AbilityUnsupported:
      additionalProperties: false
      description: >-
        The action is not possible for this chat or task as it is, and nothing
        the person does here changes that.
      properties:
        availability:
          enum:
            - unsupported
          type: string
        reason:
          $ref: '#/components/schemas/AbilityMessage'
      required:
        - availability
        - reason
      type: object
    ConversationAttachment:
      additionalProperties: false
      properties:
        filename:
          minLength: 1
          type: string
        index:
          maximum: 9
          minimum: 0
          type: integer
        media_type:
          minLength: 1
          type: string
        message_id:
          format: uuid
          type: string
        sha256:
          pattern: ^[0-9a-f]{64}$
          type: string
        task_id:
          format: uuid
          type: string
      required:
        - filename
        - media_type
        - task_id
        - message_id
        - index
        - sha256
      type: object
    TimelineMessageEventCard:
      discriminator:
        mapping:
          auto_rebase: '#/components/schemas/TimelineAutoRebaseMessageEvent'
          child_turn_result: '#/components/schemas/TimelineChildTurnResultMessageEvent'
          ci_failure: '#/components/schemas/TimelineCIFailureMessageEvent'
          external: '#/components/schemas/TimelineExternalMessageEvent'
          github_batch: '#/components/schemas/TimelineGitHubBatchMessageEvent'
          idle_compaction: '#/components/schemas/TimelineIdleCompactionMessageEvent'
          local_parent_message: '#/components/schemas/TimelineLocalParentMessageMessageEvent'
          parent_message: '#/components/schemas/TimelineParentMessageMessageEvent'
          peer_message: '#/components/schemas/TimelinePeerMessageMessageEvent'
          pr_comment: '#/components/schemas/TimelinePRCommentMessageEvent'
          pr_review: '#/components/schemas/TimelinePRReviewMessageEvent'
          task_signal_batch: '#/components/schemas/TimelineTaskSignalBatchMessageEvent'
          task_stopped: '#/components/schemas/TaskStoppedMessageEvent'
        propertyName: kind
      oneOf:
        - $ref: '#/components/schemas/TimelinePRCommentMessageEvent'
        - $ref: '#/components/schemas/TimelineCIFailureMessageEvent'
        - $ref: '#/components/schemas/TimelineAutoRebaseMessageEvent'
        - $ref: '#/components/schemas/TimelinePRReviewMessageEvent'
        - $ref: '#/components/schemas/TimelineExternalMessageEvent'
        - $ref: '#/components/schemas/TimelineGitHubBatchMessageEvent'
        - $ref: '#/components/schemas/TimelineParentMessageMessageEvent'
        - $ref: '#/components/schemas/TimelineTaskSignalBatchMessageEvent'
        - $ref: '#/components/schemas/TimelineChildTurnResultMessageEvent'
        - $ref: '#/components/schemas/TimelineLocalParentMessageMessageEvent'
        - $ref: '#/components/schemas/TimelineIdleCompactionMessageEvent'
        - $ref: '#/components/schemas/TimelinePeerMessageMessageEvent'
        - $ref: '#/components/schemas/TaskStoppedMessageEvent'
    TaskPerson:
      discriminator:
        mapping:
          github_account: '#/components/schemas/TaskGitHubPerson'
          user: '#/components/schemas/TaskUserPerson'
        propertyName: kind
      oneOf:
        - $ref: '#/components/schemas/TaskUserPerson'
        - $ref: '#/components/schemas/TaskGitHubPerson'
    AskUserToolResponse:
      additionalProperties: false
      properties:
        data:
          additionalProperties: false
          properties:
            answers:
              additionalProperties:
                items:
                  format: int64
                  minimum: -1
                  type: integer
                type: array
              type: object
            custom_answers:
              additionalProperties:
                type: string
              type: object
          required:
            - answers
          type: object
        tool_name:
          enum:
            - ask_user
          type: string
      required:
        - tool_name
        - data
      type: object
    ProposePlanToolResponse:
      additionalProperties: false
      properties:
        data:
          additionalProperties: false
          properties:
            approved:
              type: boolean
            feedback:
              type: string
          required:
            - approved
          type: object
        tool_name:
          enum:
            - propose_plan
          type: string
      required:
        - tool_name
        - data
      type: object
    MessageFailure:
      additionalProperties: false
      description: >-
        Why the message never reached the agent. hold_expired: Aether held it
        until its deadline. stopped: a stop ended it. chat_archived: its chat
        was archived. session_gone: the agent's session is gone.
        session_unreachable: the computer could not reach the session.
        slash_commands_unsupported: the computer runs no slash command sent from
        Aether. run_failed: the computer could not start its turn.
        credential_ended: the sign-in or API key it was sent with ended.
        computer_unreachable: its computer could not be reached before its
        hand-over expired. computer_cli_outdated: the computer's Aether CLI is
        too old to take it.
      properties:
        code:
          enum:
            - hold_expired
            - stopped
            - chat_archived
            - session_gone
            - session_unreachable
            - slash_commands_unsupported
            - run_failed
            - credential_ended
            - computer_unreachable
            - computer_cli_outdated
          type: string
        message:
          minLength: 1
          type: string
      required:
        - code
        - message
      type: object
    QueuedMessageWaiting:
      additionalProperties: false
      description: >-
        Why the message has not left Aether. turn_running: its chat's turn runs.
        other_chat_turn: another chat's turn runs, which waits_for names.
        earlier_message: an earlier message of its chat is on its way.
        computer_unreachable: its computer cannot be reached. chat_being_forked:
        its chat's work is being handed to a fork. open_in_terminal,
        agent_starts_off, agent_limit, chat_busy, not_signed_in,
        agent_not_installed: the computer holds its run back for that reason.
      properties:
        code:
          enum:
            - turn_running
            - other_chat_turn
            - earlier_message
            - computer_unreachable
            - chat_being_forked
            - open_in_terminal
            - agent_starts_off
            - agent_limit
            - chat_busy
            - not_signed_in
            - agent_not_installed
            - on_its_way
            - sandbox_not_ready
            - provider_overloaded
            - billing_blocked
            - org_task_concurrency_exceeded
            - credits_exhausted
            - workspace_run_unavailable
          type: string
        message:
          minLength: 1
          type: string
      required:
        - code
        - message
      type: object
    SentMessageWaiting:
      additionalProperties: false
      description: >-
        Where the message is. on_its_way: handed to the computer, whose agent
        has not taken it and which has not queued it behind a turn. with_agent:
        in the agent's inbox, or the prompt of a run that started.
      properties:
        code:
          enum:
            - on_its_way
            - with_agent
          type: string
        message:
          minLength: 1
          type: string
      required:
        - code
        - message
      type: object
    PendingInputAnswerPermission:
      additionalProperties: false
      description: >-
        The answer that closed the request: its body without pending_input, with
        when it was answered.
      properties:
        answered_at:
          format: date-time
          type: string
        decision:
          description: One of the request's decisions, by its id.
          pattern: ^[a-z][a-z0-9_]{0,63}$
          type: string
        kind:
          enum:
            - permission
          type: string
        message:
          description: >-
            What goes back to the agent with a decision whose takes_message is
            true; trimmed, a blank one is none, at most 2000 characters.
          type: string
      required:
        - kind
        - answered_at
        - decision
      type: object
    PendingInputAbilities:
      additionalProperties: false
      properties:
        answer:
          $ref: '#/components/schemas/Ability'
      required:
        - answer
      type: object
    PendingInputDecision:
      additionalProperties: false
      properties:
        id:
          description: Names the decision in an answer.
          pattern: ^[a-z][a-z0-9_]{0,63}$
          type: string
        label:
          description: The label of the decision's button.
          minLength: 1
          type: string
        rule:
          description: >-
            Present on a decision that adds, for the agent's session alone,
            rules the agent itself suggested: those rules as the agent writes
            them, such as Bash(npm test *), several joined with ", ". Text a
            computer wrote, at most 200 characters with no link, address or
            domain: show it as code, beside the label, never inside a sentence.
          minLength: 1
          type: string
        takes_message:
          description: Whether a message may go with the decision.
          type: boolean
      required:
        - id
        - label
        - takes_message
      type: object
    PendingInputAnswerPlan:
      additionalProperties: false
      description: >-
        The answer that closed the request: its body without pending_input, with
        when it was answered.
      properties:
        answered_at:
          format: date-time
          type: string
        decision:
          description: One of the request's decisions, by its id.
          pattern: ^[a-z][a-z0-9_]{0,63}$
          type: string
        kind:
          enum:
            - plan
          type: string
        message:
          description: >-
            What goes back to the agent with a decision whose takes_message is
            true; trimmed, a blank one is none, at most 2000 characters.
          type: string
      required:
        - kind
        - answered_at
        - decision
      type: object
    PendingInputAnswerQuestions:
      additionalProperties: false
      description: >-
        The answer that closed the request: its body without pending_input, with
        when it was answered.
      properties:
        answered_at:
          format: date-time
          type: string
        answers:
          additionalProperties:
            items:
              format: int64
              minimum: -1
              type: integer
            type: array
          description: >-
            Each question's index to the indexes of the options chosen; -1 is
            the person's own text, in custom_answers under the same index.
          type: object
        custom_answers:
          additionalProperties:
            type: string
          description: >-
            A question's index to the person's own answer; trimmed, at most 2000
            characters.
          type: object
        kind:
          enum:
            - questions
          type: string
      required:
        - kind
        - answered_at
        - answers
      type: object
    AskUserQuestion:
      additionalProperties: false
      properties:
        header:
          type: string
        id:
          type: string
        multi_select:
          type: boolean
        options:
          items:
            $ref: '#/components/schemas/AskUserQuestionOption'
          type: array
        question:
          minLength: 1
          pattern: \S
          type: string
      required:
        - question
        - options
      type: object
    AbilityMessage:
      additionalProperties: false
      description: >-
        A note on an available ability, or the reason a refused ability is
        refused.
      properties:
        code:
          description: >-
            What the note or reason is, as a code a client may branch on. An
            open set: a client shows the message of a code it does not know.
          pattern: ^[a-z][a-z0-9_]*$
          type: string
        message:
          description: A full sentence in plain text, written for the person who reads it.
          maxLength: 200
          minLength: 1
          type: string
          x-aether-string-length-unit: unicode-code-point
      required:
        - code
        - message
      type: object
    TimelineAutoRebaseMessageEvent:
      additionalProperties: false
      properties:
        base_branch:
          minLength: 1
          pattern: \S
          type: string
        branch:
          minLength: 1
          pattern: \S
          type: string
        head_sha:
          minLength: 1
          pattern: \S
          type: string
        kind:
          enum:
            - auto_rebase
          type: string
        mergeable_state:
          minLength: 1
          pattern: \S
          type: string
        pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        reason:
          type: string
        repo:
          $ref: '#/components/schemas/MessageEventRepo'
        url:
          format: uri
          type: string
      required:
        - kind
        - repo
        - pr_number
      type: object
    TimelineChildTurnResultMessageEvent:
      additionalProperties: false
      properties:
        child_pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        child_task_id:
          format: uuid
          pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
          type: string
        child_task_name:
          minLength: 1
          pattern: \S
          type: string
        continuation:
          additionalProperties: false
          properties:
            tool:
              enum:
                - aether_read_task_messages
              type: string
          required:
            - tool
          type: object
        kind:
          enum:
            - child_turn_result
          type: string
        outcome:
          additionalProperties: false
          properties:
            content:
              minLength: 1
              pattern: \S
              type: string
            kind:
              enum:
                - response
                - question
                - error
                - pr_ready
              type: string
          required:
            - kind
            - content
          type: object
      required:
        - kind
        - child_task_id
        - outcome
        - child_task_name
      type: object
    TimelineCIFailureMessageEvent:
      additionalProperties: false
      properties:
        branch:
          minLength: 1
          pattern: \S
          type: string
        checks:
          items:
            additionalProperties: false
            properties:
              conclusion:
                minLength: 1
                pattern: \S
                type: string
              job_id:
                format: int64
                maximum: 9007199254740991
                minimum: 1
                type: integer
              name:
                minLength: 1
                pattern: \S
                type: string
              summary:
                type: string
            required:
              - name
              - conclusion
              - job_id
            type: object
          type: array
        kind:
          enum:
            - ci_failure
          type: string
        pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        repo:
          $ref: '#/components/schemas/MessageEventRepo'
        url:
          format: uri
          type: string
      required:
        - kind
        - repo
        - pr_number
        - checks
      type: object
    TimelineExternalMessageEvent:
      additionalProperties: false
      properties:
        data:
          additionalProperties:
            type:
              - string
              - number
              - boolean
              - 'null'
          properties:
            actor:
              type: string
            context:
              type: string
            title:
              type: string
            url:
              type: string
          propertyNames:
            pattern: \S
            type: string
          type: object
        kind:
          enum:
            - external
          type: string
        source:
          enum:
            - slack
            - linear
            - sentry
            - email
          type: string
      required:
        - kind
        - source
      type: object
    TimelineGitHubBatchMessageEvent:
      additionalProperties: false
      properties:
        events:
          items:
            discriminator:
              mapping:
                ci_failure: '#/components/schemas/TimelineCIFailureMessageEvent'
                pr_comment: '#/components/schemas/TimelinePRCommentMessageEvent'
                pr_review: '#/components/schemas/TimelinePRReviewMessageEvent'
              propertyName: kind
            oneOf:
              - $ref: '#/components/schemas/TimelinePRCommentMessageEvent'
              - $ref: '#/components/schemas/TimelineCIFailureMessageEvent'
              - $ref: '#/components/schemas/TimelinePRReviewMessageEvent'
          minItems: 2
          type: array
        kind:
          enum:
            - github_batch
          type: string
      required:
        - kind
        - events
      type: object
    TimelineIdleCompactionMessageEvent:
      additionalProperties: false
      properties:
        kind:
          enum:
            - idle_compaction
          type: string
      required:
        - kind
      type: object
    TimelineLocalParentMessageMessageEvent:
      additionalProperties: false
      properties:
        client:
          enum:
            - claude-code
            - codex
            - personal-agent
            - mcp-connection
            - claude_code
            - personal_agent
            - mcp_connection
          type: string
        kind:
          enum:
            - local_parent_message
          type: string
        local_conversation_id:
          format: uuid
          pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
          type: string
      required:
        - kind
        - local_conversation_id
        - client
      type: object
    TimelineParentMessageMessageEvent:
      additionalProperties: false
      properties:
        kind:
          enum:
            - parent_message
          type: string
        parent_task_id:
          format: uuid
          pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
          type: string
        parent_task_name:
          minLength: 1
          pattern: \S
          type: string
      required:
        - kind
        - parent_task_id
        - parent_task_name
      type: object
    TimelinePeerMessageMessageEvent:
      additionalProperties: false
      properties:
        frame:
          enum:
            - cross_session
            - teammate
            - agent
          type: string
        from:
          minLength: 1
          pattern: \S
          type: string
        kind:
          enum:
            - peer_message
          type: string
        self_sent:
          type: boolean
      required:
        - kind
        - frame
        - self_sent
      type: object
    TimelinePRCommentMessageEvent:
      additionalProperties: false
      properties:
        action:
          minLength: 1
          pattern: \S
          type: string
        author:
          additionalProperties: false
          properties:
            association:
              minLength: 1
              pattern: \S
              type: string
            login:
              minLength: 1
              pattern: \S
              type: string
            type:
              minLength: 1
              pattern: \S
              type: string
          required:
            - login
          type: object
        body:
          minLength: 1
          pattern: \S
          type: string
        branch:
          minLength: 1
          pattern: \S
          type: string
        kind:
          enum:
            - pr_comment
          type: string
        line:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        path:
          minLength: 1
          pattern: \S
          type: string
        pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        repo:
          $ref: '#/components/schemas/MessageEventRepo'
        review_id:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        review_state:
          minLength: 1
          pattern: \S
          type: string
        reviewer_task_id:
          format: uuid
          type: string
        url:
          format: uri
          type: string
      required:
        - kind
        - repo
        - pr_number
        - author
        - body
      type: object
    TimelinePRReviewMessageEvent:
      additionalProperties: false
      properties:
        action:
          enum:
            - opened
            - synchronize
            - ready_for_review
            - aether_review_comment
            - manual
          type: string
        branch:
          minLength: 1
          pattern: \S
          type: string
        head_sha:
          minLength: 1
          pattern: \S
          type: string
        kind:
          enum:
            - pr_review
          type: string
        pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        repo:
          $ref: '#/components/schemas/MessageEventRepo'
        url:
          format: uri
          type: string
      required:
        - kind
        - repo
        - pr_number
        - head_sha
        - action
      type: object
    TimelineTaskSignalBatchMessageEvent:
      additionalProperties: false
      properties:
        entries:
          items:
            discriminator:
              mapping:
                auto_rebase: '#/components/schemas/TimelineTaskSignalAutoRebaseMessageEvent'
                child_turn_result: '#/components/schemas/TimelineChildTurnResultMessageEvent'
                ci_failure: '#/components/schemas/TimelineCIFailureMessageEvent'
                pr_comment: '#/components/schemas/TimelinePRCommentMessageEvent'
                pr_review: '#/components/schemas/TimelinePRReviewMessageEvent'
              propertyName: kind
            oneOf:
              - $ref: '#/components/schemas/TimelinePRCommentMessageEvent'
              - $ref: '#/components/schemas/TimelineCIFailureMessageEvent'
              - $ref: '#/components/schemas/TimelineTaskSignalAutoRebaseMessageEvent'
              - $ref: '#/components/schemas/TimelinePRReviewMessageEvent'
              - $ref: '#/components/schemas/TimelineChildTurnResultMessageEvent'
          minItems: 1
          type: array
        kind:
          enum:
            - task_signal_batch
          type: string
      required:
        - kind
        - entries
      type: object
    TaskStoppedMessageEvent:
      additionalProperties: false
      properties:
        initiator:
          discriminator:
            mapping:
              agent: '#/components/schemas/AgentStopInitiator'
              integration: '#/components/schemas/IntegrationStopInitiator'
              local_agent: '#/components/schemas/LocalAgentStopInitiator'
              system: '#/components/schemas/SystemStopInitiator'
              unknown: '#/components/schemas/UnknownStopInitiator'
              user: '#/components/schemas/UserStopInitiator'
            propertyName: kind
          oneOf:
            - $ref: '#/components/schemas/UserStopInitiator'
            - $ref: '#/components/schemas/IntegrationStopInitiator'
            - $ref: '#/components/schemas/SystemStopInitiator'
            - $ref: '#/components/schemas/AgentStopInitiator'
            - $ref: '#/components/schemas/LocalAgentStopInitiator'
            - $ref: '#/components/schemas/UnknownStopInitiator'
        kind:
          enum:
            - task_stopped
          type: string
      required:
        - kind
        - initiator
      type: object
    TaskGitHubPerson:
      additionalProperties: false
      properties:
        github_id:
          format: int64
          minimum: 1
          type: integer
        kind:
          enum:
            - github_account
          type: string
        login:
          minLength: 1
          pattern: \S
          type: string
      required:
        - kind
        - login
        - github_id
      type: object
    TaskUserPerson:
      additionalProperties: false
      properties:
        display_name:
          minLength: 1
          pattern: \S
          type: string
        github_login:
          minLength: 1
          pattern: \S
          type:
            - string
            - 'null'
        kind:
          enum:
            - user
          type: string
        user_id:
          format: uuid
          type: string
      required:
        - kind
        - user_id
        - display_name
        - github_login
      type: object
    AskUserQuestionOption:
      additionalProperties: false
      properties:
        description:
          type: string
        label:
          minLength: 1
          pattern: \S
          type: string
        preview:
          type: string
      required:
        - label
      type: object
    MessageEventRepo:
      additionalProperties: false
      properties:
        name:
          minLength: 1
          pattern: \S
          type: string
        owner:
          minLength: 1
          pattern: \S
          type: string
      required:
        - owner
        - name
      type: object
    TimelineTaskSignalAutoRebaseMessageEvent:
      additionalProperties: false
      properties:
        base_branch:
          minLength: 1
          pattern: \S
          type: string
        branch:
          minLength: 1
          pattern: \S
          type: string
        head_sha:
          minLength: 1
          pattern: \S
          type: string
        kind:
          enum:
            - auto_rebase
          type: string
        mergeable_state:
          enum:
            - behind
            - dirty
          type: string
        pr_number:
          format: int64
          maximum: 9007199254740991
          minimum: 1
          type: integer
        reason:
          minLength: 1
          pattern: \S
          type: string
        repo:
          $ref: '#/components/schemas/MessageEventRepo'
        url:
          format: uri
          type: string
      required:
        - kind
        - repo
        - pr_number
        - branch
        - url
        - base_branch
        - head_sha
        - mergeable_state
        - reason
      type: object
    AgentStopInitiator:
      additionalProperties: false
      properties:
        kind:
          enum:
            - agent
          type: string
        parent_task_id:
          format: uuid
          type: string
        parent_task_name:
          minLength: 1
          type: string
      required:
        - kind
        - parent_task_id
        - parent_task_name
      type: object
    IntegrationStopInitiator:
      additionalProperties: false
      properties:
        external_actor_id:
          minLength: 1
          type: string
        kind:
          enum:
            - integration
          type: string
        provider:
          enum:
            - linear
          type: string
      required:
        - kind
        - provider
        - external_actor_id
      type: object
    LocalAgentStopInitiator:
      additionalProperties: false
      properties:
        client:
          enum:
            - claude-code
            - codex
            - personal-agent
            - mcp-connection
            - claude_code
            - personal_agent
            - mcp_connection
          type: string
        kind:
          enum:
            - local_agent
          type: string
        local_conversation_id:
          format: uuid
          type: string
      required:
        - kind
        - local_conversation_id
        - client
      type: object
    SystemStopInitiator:
      additionalProperties: false
      properties:
        kind:
          enum:
            - system
          type: string
        reason:
          enum:
            - history_rollback
            - runtime_billing_failure
            - service_shutdown
          type: string
      required:
        - kind
        - reason
      type: object
    UnknownStopInitiator:
      additionalProperties: false
      properties:
        kind:
          enum:
            - unknown
          type: string
      required:
        - kind
      type: object
    UserStopInitiator:
      additionalProperties: false
      properties:
        kind:
          enum:
            - user
          type: string
        source:
          enum:
            - aether
            - slack
          type: string
        user_id:
          format: uuid
          type: string
      required:
        - kind
        - user_id
        - source
      type: object
  securitySchemes:
    bearerAuth:
      bearerFormat: JWT
      scheme: bearer
      type: http

````

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