client.h

Go to the documentation of this file.

//
// Copyright (c) 2024-2026, Daily
//
// SPDX-License-Identifier: BSD-2-Clause
//
 
 
#ifndef PIPECAT_CLIENT_H
#define PIPECAT_CLIENT_H
 
#include "pipecat/rtvi/messages.h"
#include "pipecat/transport.h"
 
#include <nlohmann/json.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <future>
#include <map>
#include <memory>
#include <optional>
#include <string>
 
namespace pipecat {
 
using FunctionCallResultCallback = std::function<void(nlohmann::json result)>;
 
class PipecatClientCallbacks {
   public:
    virtual ~PipecatClientCallbacks() = default;
 
 
    virtual void on_transport_state_changed(TransportState /* state */) {}
 
    virtual void on_connected() {}
 
    virtual void on_disconnected() {}
 
    virtual void on_error(const rtvi::ErrorData& /* error */) {}
 
 
 
    virtual void on_bot_started(const nlohmann::json& /* response */) {}
 
    virtual void on_bot_connected(const Participant& /* bot */) {}
 
    virtual void on_bot_ready(const rtvi::BotReadyData& /* data */) {}
 
    virtual void on_bot_disconnected(const Participant& /* bot */) {}
 
    virtual void on_participant_joined(const Participant& /* participant */) {}
 
    virtual void on_participant_left(const Participant& /* participant */) {}
 
 
 
    virtual void on_server_message(const nlohmann::json& /* data */) {}
 
    virtual void on_message_error(const rtvi::ErrorData& /* error */) {}
 
    virtual void on_metrics(const rtvi::MetricsData& /* data */) {}
 
    virtual void on_unhandled_message(const rtvi::Message& /* message */) {}
 
 
 
    virtual void on_user_started_speaking() {}
 
    virtual void on_user_stopped_speaking() {}
 
    virtual void on_bot_started_speaking() {}
 
    virtual void on_bot_stopped_speaking() {}
 
    virtual void on_bot_interrupted() {}
 
    virtual void on_user_mute_started() {}
 
    virtual void on_user_mute_stopped() {}
 
 
 
    virtual void on_user_transcript(const rtvi::TranscriptData& /* data */) {}
 
    virtual void on_user_llm_text(const rtvi::UserLLMTextData& /* data */) {}
 
    virtual void on_bot_output(const rtvi::BotOutputData& /* data */) {}
 
 
 
    virtual void on_bot_llm_started() {}
 
    virtual void on_bot_llm_stopped() {}
 
    virtual void on_bot_llm_text(const rtvi::BotLLMTextData& /* data */) {}
 
    virtual void on_bot_llm_search_response(
            const rtvi::BotLLMSearchResponseData& /* data */
    ) {}
 
 
 
    virtual void on_llm_function_call_started(
            const rtvi::LLMFunctionCallStartedData& /* data */
    ) {}
 
    virtual void on_llm_function_call_in_progress(
            const rtvi::LLMFunctionCallInProgressData& /* data */,
            FunctionCallResultCallback /* respond */
    ) {}
 
    virtual void on_llm_function_call_stopped(
            const rtvi::LLMFunctionCallStoppedData& /* data */
    ) {}
 
 
 
    virtual void on_bot_tts_started() {}
 
    virtual void on_bot_tts_stopped() {}
 
    virtual void on_bot_tts_text(const rtvi::BotTTSTextData& /* data */) {}
 
};
 
struct APIRequest {
    std::string endpoint;
    std::map<std::string, std::string> headers;
    nlohmann::json request_data;
    std::chrono::milliseconds timeout {0};
};
 
struct ClientResponse {
    nlohmann::json data;
    std::optional<std::string> error;
    bool timed_out = false;
};
 
using ClientResponseCallback = std::function<void(const ClientResponse&)>;
 
struct PipecatClientOptions {
    std::unique_ptr<Transport> transport;
    PipecatClientCallbacks* callbacks = nullptr;
    bool disconnect_on_bot_disconnect = true;
    std::chrono::milliseconds connect_timeout = std::chrono::seconds(30);
    rtvi::AboutClientData about = rtvi::default_about_client();
};
 
class PipecatClient {
   public:
    explicit PipecatClient(PipecatClientOptions options);
 
    ~PipecatClient();
 
    PipecatClient(const PipecatClient&) = delete;
 
    PipecatClient& operator=(const PipecatClient&) = delete;
 
 
    void initialize();
 
    nlohmann::json start_bot(const APIRequest& request);
 
    rtvi::BotReadyData connect(
            const nlohmann::json& transport_params = nullptr
    );
 
    rtvi::BotReadyData start_bot_and_connect(const APIRequest& request);
 
    void disconnect();
 
    TransportState state() const;
 
    bool connected() const;
 
    Transport& transport();
 
 
 
    int32_t send_user_audio(const int16_t* frames, size_t num_frames);
 
    int32_t read_bot_audio(int16_t* frames, size_t num_frames);
 
 
 
    void send_text(
            const std::string& content,
            const rtvi::SendTextOptions& options = {}
    );
 
    void send_client_message(
            const std::string& type,
            const nlohmann::json& data = nullptr
    );
 
    void disconnect_bot();
 
    void send_dtmf(const std::string& buttons);
 
 
 
    void send_client_request(
            const std::string& type,
            const nlohmann::json& data,
            ClientResponseCallback callback,
            std::chrono::milliseconds timeout = std::chrono::seconds(10)
    );
 
    std::future<nlohmann::json> send_client_request(
            const std::string& type,
            const nlohmann::json& data = nullptr,
            std::chrono::milliseconds timeout = std::chrono::seconds(10)
    );
 
 
   private:
    class Impl;
    std::unique_ptr<Impl> _impl;
};
 
}  // namespace pipecat
 
#endif