errors.h

Go to the documentation of this file.

//
// Copyright (c) 2024-2026, Daily
//
// SPDX-License-Identifier: BSD-2-Clause
//
 
 
#ifndef PIPECAT_ERRORS_H
#define PIPECAT_ERRORS_H
 
#include <stdexcept>
#include <string>
 
namespace pipecat {
 
class PipecatError : public std::runtime_error {
   public:
    using std::runtime_error::runtime_error;
};
 
class StartBotError : public PipecatError {
   public:
    explicit StartBotError(const std::string& message, int status = 0)
        : PipecatError(message), _status(status) {}
 
    int status() const { return _status; }
 
   private:
    int _status;
};
 
class ConnectionTimeoutError : public PipecatError {
   public:
    explicit ConnectionTimeoutError(
            const std::string& message =
                    "Bot did not become ready within the connect timeout"
    )
        : PipecatError(message) {}
};
 
class TransportStartError : public PipecatError {
   public:
    explicit TransportStartError(
            const std::string& message = "Unable to connect the transport"
    )
        : PipecatError(message) {}
};
 
class InvalidTransportParamsError : public PipecatError {
   public:
    explicit InvalidTransportParamsError(
            const std::string& message = "Invalid transport connection params"
    )
        : PipecatError(message) {}
};
 
class BotNotReadyError : public PipecatError {
   public:
    explicit BotNotReadyError(
            const std::string& message =
                    "Bot is not ready, call connect() first"
    )
        : PipecatError(message) {}
};
 
class BotAlreadyStartedError : public PipecatError {
   public:
    explicit BotAlreadyStartedError(
            const std::string& message =
                    "Client already started, call disconnect() first"
    )
        : PipecatError(message) {}
};
 
class UnsupportedFeatureError : public PipecatError {
   public:
    explicit UnsupportedFeatureError(
            const std::string& feature,
            const std::string& message = ""
    )
        : PipecatError(
                  feature + " not supported" +
                  (message.empty() ? "" : ": " + message)
          ),
          _feature(feature) {}
 
    const std::string& feature() const { return _feature; }
 
   private:
    std::string _feature;
};
 
class MessageError : public PipecatError {
   public:
    using PipecatError::PipecatError;
};
 
class RequestTimeoutError : public MessageError {
   public:
    explicit RequestTimeoutError(
            const std::string& message = "Timed out waiting for a response"
    )
        : MessageError(message) {}
};
 
class MessageTooLargeError : public PipecatError {
   public:
    explicit MessageTooLargeError(
            const std::string& message =
                    "Message size exceeds the transport's limit"
    )
        : PipecatError(message) {}
};
 
}  // namespace pipecat
 
#endif