async sendMessage(
    text: string,
    opts: types.SendMessageBrowserOptions = {}
  ): Promise<types.ChatMessage> {
    if (!!opts.conversationId !== !!opts.parentMessageId) {
      throw new Error(
        'ChatGPTUnofficialProxyAPI.sendMessage: conversationId and parentMessageId must both be set or both be undefined'
      )
    }

    if (opts.conversationId && !isValidUUIDv4(opts.conversationId)) {
      throw new Error(
        'ChatGPTUnofficialProxyAPI.sendMessage: conversationId is not a valid v4 UUID'
      )
    }

    if (opts.parentMessageId && !isValidUUIDv4(opts.parentMessageId)) {
      throw new Error(
        'ChatGPTUnofficialProxyAPI.sendMessage: parentMessageId is not a valid v4 UUID'
      )
    }

    if (opts.messageId && !isValidUUIDv4(opts.messageId)) {
      throw new Error(
        'ChatGPTUnofficialProxyAPI.sendMessage: messageId is not a valid v4 UUID'
      )
    }

    const {
      conversationId,
      parentMessageId = uuidv4(),
      messageId = uuidv4(),
      action = 'next',
      timeoutMs,
      onProgress
    } = opts

    let {abortSignal} = opts

    let abortController: AbortController = null
    if (timeoutMs && !abortSignal) {
      abortController = new AbortController()
      abortSignal = abortController.signal
    }

    const body: types.ConversationJSONBody = {
      action,
      messages: [
        {
          id: messageId,
          role: 'user',
          content: {
            content_type: 'text',
            parts: [text]
          }
        }
      ],
      model: this._model,
      parent_message_id: parentMessageId
    }

    if (conversationId) {
      body.conversation_id = conversationId
    }

    const result: types.ChatMessage = {
      role: 'assistant',
      id: uuidv4(),
      parentMessageId: messageId,
      conversationId,
      text: ''
    }

    const responseP = new Promise<types.ChatMessage>((resolve, reject) => {
      const url = this._apiReverseProxyUrl
      const headers = {
        ...this._headers,
        Authorization: `Bearer ${this._accessToken}`,
        Accept: 'text/event-stream',
        'Content-Type': 'application/json'
      }

      if (this._debug) {
        console.log('POST', url, {body, headers})
      }

      const onProgressPromise = new Promise<void>((res, rej) => {
        fetchSSE(
          url,
          {
            method: 'POST',
            headers,
            body: JSON.stringify(body),
            signal: abortSignal,
            onMessage: (data: string) => {
              if (data === '[DONE]') {
                return resolve(result)
              }

              try {
                const convoResponseEvent: types.ConversationResponseEvent =
                  JSON.parse(data)
                if (convoResponseEvent.conversation_id) {
                  result.conversationId = convoResponseEvent.conversation_id
                }

                if (convoResponseEvent.message?.id) {
                  result.id = convoResponseEvent.message.id
                }

                const message = convoResponseEvent.message
                // console.log('event', JSON.stringify(convoResponseEvent, null, 2))

                if (message) {
                  let text = message?.content?.parts?.[0]

                  if (text) {
                    result.text = text

                    if (onProgress) {
                      onProgress(result)
                      res()
                    }
                  }
                }
              } catch (err) {
                // ignore for now; there seem to be some non-json messages
                // console.warn('fetchSSE onMessage unexpected error', err)
              }
            }
          },
          this._fetch
        ).catch((err) => {
          const errMessageL = err.toString().toLowerCase()

          if (
            result.text &&
            (errMessageL === 'error: typeerror: terminated' ||
              errMessageL === 'typeerror: terminated')
          ) {
            // OpenAI sometimes forcefully terminates the socket from their end before
            // the HTTP request has resolved cleanly. In my testing, these cases tend to
            // happen when OpenAI has already send the last `response`, so we can ignore
            // the `fetch` error in this case.
            return resolve(result)
          } else {
            return reject(err)
          }
        })
      })

      ;(onProgressPromise as any).cancel = () => {
        abortController.abort()
      }

      return pTimeout(onProgressPromise, {
          milliseconds: 10000,
          message: 'Caught onProgress timeout'
      }).catch((e) => console.log(e));
    });

    if (timeoutMs) {
      if (abortController) {
        // This will be called when a timeout occurs in order for us to forcibly
        // ensure that the underlying HTTP request is aborted.
        ;(responseP as any).cancel = () => {
          abortController.abort()
        }
      }

      return pTimeout(responseP, {
        milliseconds: timeoutMs,
        message: 'ChatGPT timed out waiting for response'
      })
    } else {
      return responseP
    }
  }