diff --git a/livekit-protocol/generate_proto.sh b/livekit-protocol/generate_proto.sh index e3df93b23..2c5dbe725 100755 --- a/livekit-protocol/generate_proto.sh +++ b/livekit-protocol/generate_proto.sh @@ -35,4 +35,8 @@ protoc \ $PROTOCOL/livekit_connector.proto \ $PROTOCOL/livekit_connector_whatsapp.proto \ $PROTOCOL/livekit_connector_twilio.proto \ - $PROTOCOL/livekit_analytics.proto + $PROTOCOL/livekit_analytics.proto \ + $PROTOCOL/agent/livekit_agent_dev.proto \ + $PROTOCOL/agent/livekit_agent_session.proto \ + $PROTOCOL/agent/livekit_agent_text.proto \ + $PROTOCOL/agent/livekit_agent_inference.proto diff --git a/livekit-protocol/src/lib.rs b/livekit-protocol/src/lib.rs index ce8ed8a63..094381f31 100644 --- a/livekit-protocol/src/lib.rs +++ b/livekit-protocol/src/lib.rs @@ -16,3 +16,10 @@ #![allow(clippy::large_enum_variant)] include!("livekit.rs"); + +/// The `livekit.agent` protobuf package: `AgentSessionEvent`, `SessionRequest` and the agent +/// worker/inference messages. Generated by `generate_proto.sh`; a new package needs its own +/// `include!` or the types exist on disk and are reachable from nowhere. +pub mod agent { + include!("livekit.agent.rs"); +} diff --git a/livekit-protocol/src/livekit.agent.rs b/livekit-protocol/src/livekit.agent.rs new file mode 100644 index 000000000..27a3b616c --- /dev/null +++ b/livekit-protocol/src/livekit.agent.rs @@ -0,0 +1,1560 @@ +// @generated +// This file is @generated by prost-build. +/// AgentDevMessage is used for IPC between the CLI and agent processes +/// during dev-mode hot reload. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentDevMessage { + #[prost(oneof="agent_dev_message::Message", tags="1, 2, 3")] + pub message: ::core::option::Option, +} +/// Nested message and enum types in `AgentDevMessage`. +pub mod agent_dev_message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Message { + #[prost(message, tag="1")] + GetRunningJobsRequest(super::GetRunningAgentJobsRequest), + #[prost(message, tag="2")] + GetRunningJobsResponse(super::GetRunningAgentJobsResponse), + #[prost(message, tag="3")] + ServerInfo(super::ServerInfo), + } +} +/// ServerInfo is sent by the agent to the CLI when the dev-reload channel opens, +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ServerInfo { + #[prost(string, tag="1")] + pub agent_name: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub url: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRunningAgentJobsRequest { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRunningAgentJobsResponse { + #[prost(message, repeated, tag="1")] + pub jobs: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunningAgentJobInfo { + #[prost(bytes="vec", tag="1")] + pub job: ::prost::alloc::vec::Vec, + #[prost(string, tag="2")] + pub accept_name: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub accept_identity: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub accept_metadata: ::prost::alloc::string::String, + #[prost(string, tag="5")] + pub url: ::prost::alloc::string::String, + #[prost(string, tag="6")] + pub token: ::prost::alloc::string::String, + #[prost(string, tag="7")] + pub worker_id: ::prost::alloc::string::String, + #[prost(bool, tag="8")] + pub mock_job: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MetricsReport { + #[prost(message, optional, tag="1")] + pub started_speaking_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(message, optional, tag="2")] + pub stopped_speaking_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(double, optional, tag="3")] + pub transcription_delay: ::core::option::Option, + #[prost(double, optional, tag="4")] + pub end_of_turn_delay: ::core::option::Option, + #[prost(double, optional, tag="5")] + pub on_user_turn_completed_delay: ::core::option::Option, + #[prost(double, optional, tag="6")] + pub llm_node_ttft: ::core::option::Option, + #[prost(double, optional, tag="7")] + pub tts_node_ttfb: ::core::option::Option, + #[prost(double, optional, tag="8")] + pub e2e_latency: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimedString { + #[prost(string, tag="1")] + pub text: ::prost::alloc::string::String, + #[prost(double, optional, tag="2")] + pub start_time: ::core::option::Option, + #[prost(double, optional, tag="3")] + pub end_time: ::core::option::Option, + #[prost(double, optional, tag="4")] + pub confidence: ::core::option::Option, + #[prost(double, optional, tag="5")] + pub start_time_offset: ::core::option::Option, + #[prost(string, optional, tag="6")] + pub speaker_id: ::core::option::Option<::prost::alloc::string::String>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ChatMessage { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(enumeration="ChatRole", tag="2")] + pub role: i32, + #[prost(message, repeated, tag="3")] + pub content: ::prost::alloc::vec::Vec, + #[prost(bool, tag="4")] + pub interrupted: bool, + #[prost(double, optional, tag="5")] + pub transcript_confidence: ::core::option::Option, + #[prost(map="string, string", tag="6")] + pub extra: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + #[prost(message, optional, tag="7")] + pub metrics: ::core::option::Option, + #[prost(message, optional, tag="8")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, +} +/// Nested message and enum types in `ChatMessage`. +pub mod chat_message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ChatContent { + #[prost(oneof="chat_content::Payload", tags="1")] + pub payload: ::core::option::Option, + } + /// Nested message and enum types in `ChatContent`. + pub mod chat_content { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Payload { + #[prost(string, tag="1")] + Text(::prost::alloc::string::String), + } + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FunctionCall { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub call_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub arguments: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="5")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FunctionCallOutput { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub call_id: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub output: ::prost::alloc::string::String, + #[prost(bool, tag="5")] + pub is_error: bool, + #[prost(message, optional, tag="6")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentHandoff { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, optional, tag="2")] + pub old_agent_id: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, tag="3")] + pub new_agent_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="4")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentConfigUpdate { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, optional, tag="2")] + pub instructions: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, repeated, tag="3")] + pub tools_added: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, repeated, tag="4")] + pub tools_removed: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag="5")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ChatContext { + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `ChatContext`. +pub mod chat_context { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ChatItem { + #[prost(oneof="chat_item::Item", tags="1, 2, 3, 4, 5")] + pub item: ::core::option::Option, + } + /// Nested message and enum types in `ChatItem`. + pub mod chat_item { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Item { + #[prost(message, tag="1")] + Message(super::super::ChatMessage), + #[prost(message, tag="2")] + FunctionCall(super::super::FunctionCall), + #[prost(message, tag="3")] + FunctionCallOutput(super::super::FunctionCallOutput), + #[prost(message, tag="4")] + AgentHandoff(super::super::AgentHandoff), + #[prost(message, tag="5")] + AgentConfigUpdate(super::super::AgentConfigUpdate), + } + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LlmModelUsage { + #[prost(string, tag="1")] + pub provider: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, + #[prost(int32, tag="3")] + pub input_tokens: i32, + #[prost(int32, tag="4")] + pub input_cached_tokens: i32, + #[prost(int32, tag="5")] + pub input_audio_tokens: i32, + #[prost(int32, tag="6")] + pub input_cached_audio_tokens: i32, + #[prost(int32, tag="7")] + pub input_text_tokens: i32, + #[prost(int32, tag="8")] + pub input_cached_text_tokens: i32, + #[prost(int32, tag="9")] + pub input_image_tokens: i32, + #[prost(int32, tag="10")] + pub input_cached_image_tokens: i32, + #[prost(int32, tag="11")] + pub output_tokens: i32, + #[prost(int32, tag="12")] + pub output_audio_tokens: i32, + #[prost(int32, tag="13")] + pub output_text_tokens: i32, + #[prost(double, tag="14")] + pub session_duration: f64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TtsModelUsage { + #[prost(string, tag="1")] + pub provider: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, + #[prost(int32, tag="3")] + pub input_tokens: i32, + #[prost(int32, tag="4")] + pub output_tokens: i32, + #[prost(int32, tag="5")] + pub characters_count: i32, + #[prost(double, tag="6")] + pub audio_duration: f64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SttModelUsage { + #[prost(string, tag="1")] + pub provider: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, + #[prost(int32, tag="3")] + pub input_tokens: i32, + #[prost(int32, tag="4")] + pub output_tokens: i32, + #[prost(double, tag="5")] + pub audio_duration: f64, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterruptionModelUsage { + #[prost(string, tag="1")] + pub provider: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, + #[prost(int32, tag="3")] + pub total_requests: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotModelUsage { + #[prost(string, tag="1")] + pub provider: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub model: ::prost::alloc::string::String, + #[prost(int32, tag="3")] + pub total_requests: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ModelUsage { + #[prost(oneof="model_usage::Usage", tags="1, 2, 3, 4, 5")] + pub usage: ::core::option::Option, +} +/// Nested message and enum types in `ModelUsage`. +pub mod model_usage { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Usage { + #[prost(message, tag="1")] + Llm(super::LlmModelUsage), + #[prost(message, tag="2")] + Tts(super::TtsModelUsage), + #[prost(message, tag="3")] + Stt(super::SttModelUsage), + #[prost(message, tag="4")] + Interruption(super::InterruptionModelUsage), + #[prost(message, tag="5")] + Eot(super::EotModelUsage), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentSessionUsage { + #[prost(message, repeated, tag="1")] + pub model_usage: ::prost::alloc::vec::Vec, +} +/// Debug/trace payload carried over the remote session wire. +/// Internal: surfaced only to the debugger/recorder, not to user code. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DebugMessage { + #[prost(message, optional, tag="1")] + pub payload: ::core::option::Option<::pbjson_types::Struct>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentSessionEvent { + #[prost(message, optional, tag="1")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(oneof="agent_session_event::Event", tags="10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22")] + pub event: ::core::option::Option, +} +/// Nested message and enum types in `AgentSessionEvent`. +pub mod agent_session_event { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AgentStateChanged { + #[prost(enumeration="super::AgentState", tag="1")] + pub old_state: i32, + #[prost(enumeration="super::AgentState", tag="2")] + pub new_state: i32, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct UserStateChanged { + #[prost(enumeration="super::UserState", tag="1")] + pub old_state: i32, + #[prost(enumeration="super::UserState", tag="2")] + pub new_state: i32, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ConversationItemAdded { + #[prost(message, optional, tag="1")] + pub item: ::core::option::Option, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct UserInputTranscribed { + #[prost(string, tag="1")] + pub transcript: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub is_final: bool, + #[prost(string, optional, tag="3")] + pub language: ::core::option::Option<::prost::alloc::string::String>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct FunctionToolsStarted { + #[prost(message, repeated, tag="1")] + pub function_calls: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct FunctionToolsExecuted { + #[prost(message, repeated, tag="1")] + pub function_calls: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub function_call_outputs: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Error { + #[prost(string, tag="1")] + pub message: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct OverlappingSpeech { + #[prost(bool, tag="1")] + pub is_interruption: bool, + #[prost(message, optional, tag="2")] + pub overlap_started_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(double, tag="3")] + pub detection_delay: f64, + #[prost(message, optional, tag="4")] + pub detected_at: ::core::option::Option<::pbjson_types::Timestamp>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AmdPrediction { + #[prost(message, optional, tag="1")] + pub speech_duration: ::core::option::Option<::pbjson_types::Duration>, + #[prost(enumeration="super::AmdCategory", tag="2")] + pub category: i32, + #[prost(string, tag="3")] + pub reason: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub transcript: ::prost::alloc::string::String, + #[prost(message, optional, tag="5")] + pub delay: ::core::option::Option<::pbjson_types::Duration>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct EotPrediction { + #[prost(float, tag="1")] + pub probability: f32, + #[prost(float, tag="2")] + pub threshold: f32, + #[prost(message, optional, tag="3")] + pub inference_duration: ::core::option::Option<::pbjson_types::Duration>, + #[prost(message, optional, tag="4")] + pub delay: ::core::option::Option<::pbjson_types::Duration>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct SessionUsageUpdated { + #[prost(message, optional, tag="1")] + pub usage: ::core::option::Option, + } + /// Per-call tool lifecycle. One flat update per occurrence: a call started -> + /// progress updates while it runs (CallUpdated) -> the single terminal entry (Ended), + /// with the deferred reply voicing buffered updates advancing separately (ReplyUpdated). + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ToolExecutionUpdated { + #[prost(oneof="tool_execution_updated::Update", tags="1, 2, 3, 4")] + pub update: ::core::option::Option, + } + /// Nested message and enum types in `ToolExecutionUpdated`. + pub mod tool_execution_updated { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Started { + #[prost(message, optional, tag="1")] + pub function_call: ::core::option::Option, + } + /// a progress update emitted via ctx.update() while the call runs + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct CallUpdated { + /// synthetic id: call_id (inline) or call_id_update_N + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub call_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub message: ::prost::alloc::string::String, + } + /// the call's single terminal entry + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Ended { + /// synthetic id: call_id (inline) or call_id_final (deferred) + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub call_id: ::prost::alloc::string::String, + /// result text or error message; unset for cancelled / empty returns + #[prost(string, optional, tag="3")] + pub message: ::core::option::Option<::prost::alloc::string::String>, + /// TC_DONE, TC_ERROR, or TC_CANCELLED + #[prost(enumeration="super::super::ToolCallStatus", tag="4")] + pub status: i32, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ReplyUpdated { + /// buffered update ids covered by this reply; one reply can span calls + #[prost(string, repeated, tag="1")] + pub update_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(enumeration="super::super::ToolReplyStatus", tag="2")] + pub status: i32, + /// id of the speech that voices this reply + #[prost(string, tag="3")] + pub speech_id: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Update { + #[prost(message, tag="1")] + Started(Started), + #[prost(message, tag="2")] + CallUpdated(CallUpdated), + #[prost(message, tag="3")] + ReplyUpdated(ReplyUpdated), + #[prost(message, tag="4")] + Ended(Ended), + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Event { + #[prost(message, tag="10")] + AgentStateChanged(AgentStateChanged), + #[prost(message, tag="11")] + UserStateChanged(UserStateChanged), + #[prost(message, tag="12")] + ConversationItemAdded(ConversationItemAdded), + #[prost(message, tag="13")] + UserInputTranscribed(UserInputTranscribed), + #[prost(message, tag="14")] + FunctionToolsExecuted(FunctionToolsExecuted), + #[prost(message, tag="15")] + Error(Error), + #[prost(message, tag="16")] + OverlappingSpeech(OverlappingSpeech), + #[prost(message, tag="17")] + SessionUsageUpdated(SessionUsageUpdated), + #[prost(message, tag="18")] + AmdPrediction(AmdPrediction), + #[prost(message, tag="19")] + EotPrediction(EotPrediction), + #[prost(message, tag="20")] + FunctionToolsStarted(FunctionToolsStarted), + #[prost(message, tag="21")] + DebugMessage(super::DebugMessage), + #[prost(message, tag="22")] + ToolExecutionUpdated(ToolExecutionUpdated), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionRequest { + #[prost(string, tag="1")] + pub request_id: ::prost::alloc::string::String, + #[prost(oneof="session_request::Request", tags="2, 4, 5, 6, 7, 8, 9, 10, 11, 12")] + pub request: ::core::option::Option, +} +/// Nested message and enum types in `SessionRequest`. +pub mod session_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Ping { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetChatHistory { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct RunInput { + #[prost(string, tag="1")] + pub text: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetAgentInfo { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetSessionState { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetRtcStats { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetSessionUsage { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetFrameworkInfo { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct UpdateIo { + #[prost(message, optional, tag="1")] + pub input: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub output: ::core::option::Option, + } + /// Nested message and enum types in `UpdateIO`. + pub mod update_io { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Input { + #[prost(bool, optional, tag="1")] + pub audio_enabled: ::core::option::Option, + #[prost(bool, optional, tag="2")] + pub video_enabled: ::core::option::Option, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Output { + #[prost(bool, optional, tag="1")] + pub audio_enabled: ::core::option::Option, + #[prost(bool, optional, tag="2")] + pub video_enabled: ::core::option::Option, + #[prost(bool, optional, tag="3")] + pub transcription_enabled: ::core::option::Option, + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct FinalizeSimulation { + #[prost(bool, tag="1")] + pub provisional_success: bool, + #[prost(string, tag="2")] + pub provisional_reason: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Request { + #[prost(message, tag="2")] + Ping(Ping), + #[prost(message, tag="4")] + GetChatHistory(GetChatHistory), + #[prost(message, tag="5")] + RunInput(RunInput), + #[prost(message, tag="6")] + GetAgentInfo(GetAgentInfo), + #[prost(message, tag="7")] + GetSessionState(GetSessionState), + #[prost(message, tag="8")] + GetRtcStats(GetRtcStats), + #[prost(message, tag="9")] + GetSessionUsage(GetSessionUsage), + #[prost(message, tag="10")] + GetFrameworkInfo(GetFrameworkInfo), + #[prost(message, tag="11")] + UpdateIo(UpdateIo), + #[prost(message, tag="12")] + FinalizeSimulation(FinalizeSimulation), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionResponse { + #[prost(string, tag="1")] + pub request_id: ::prost::alloc::string::String, + #[prost(string, optional, tag="2")] + pub error: ::core::option::Option<::prost::alloc::string::String>, + #[prost(oneof="session_response::Response", tags="3, 5, 6, 7, 8, 9, 10, 11, 12, 13")] + pub response: ::core::option::Option, +} +/// Nested message and enum types in `SessionResponse`. +pub mod session_response { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Pong { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetChatHistoryResponse { + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetAgentInfoResponse { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, optional, tag="2")] + pub instructions: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, repeated, tag="3")] + pub tools: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, repeated, tag="4")] + pub chat_ctx: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct RunInputResponse { + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetSessionStateResponse { + #[prost(enumeration="super::AgentState", tag="1")] + pub agent_state: i32, + #[prost(enumeration="super::UserState", tag="2")] + pub user_state: i32, + #[prost(string, tag="3")] + pub agent_id: ::prost::alloc::string::String, + #[prost(map="string, string", tag="4")] + pub options: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + #[prost(message, optional, tag="5")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetRtcStatsResponse { + #[prost(message, repeated, tag="1")] + pub publisher_stats: ::prost::alloc::vec::Vec<::pbjson_types::Struct>, + #[prost(message, repeated, tag="2")] + pub subscriber_stats: ::prost::alloc::vec::Vec<::pbjson_types::Struct>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetSessionUsageResponse { + #[prost(message, optional, tag="1")] + pub usage: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct GetFrameworkInfoResponse { + #[prost(string, tag="1")] + pub sdk: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub sdk_version: ::prost::alloc::string::String, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct UpdateIoResponse { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct FinalizeSimulationResponse { + #[prost(message, optional, tag="1")] + pub user_verdict: ::core::option::Option, + } + /// Nested message and enum types in `FinalizeSimulationResponse`. + pub mod finalize_simulation_response { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct SimulationVerdict { + #[prost(bool, tag="1")] + pub success: bool, + #[prost(string, tag="2")] + pub reason: ::prost::alloc::string::String, + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(message, tag="3")] + Pong(Pong), + #[prost(message, tag="5")] + GetChatHistory(GetChatHistoryResponse), + #[prost(message, tag="6")] + RunInput(RunInputResponse), + #[prost(message, tag="7")] + GetAgentInfo(GetAgentInfoResponse), + #[prost(message, tag="8")] + GetSessionState(GetSessionStateResponse), + #[prost(message, tag="9")] + GetRtcStats(GetRtcStatsResponse), + #[prost(message, tag="10")] + GetSessionUsage(GetSessionUsageResponse), + #[prost(message, tag="11")] + GetFrameworkInfo(GetFrameworkInfoResponse), + #[prost(message, tag="12")] + UpdateIo(UpdateIoResponse), + #[prost(message, tag="13")] + FinalizeSimulation(FinalizeSimulationResponse), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentSessionMessage { + #[prost(oneof="agent_session_message::Message", tags="1, 2, 3, 4, 5, 6, 7, 8")] + pub message: ::core::option::Option, +} +/// Nested message and enum types in `AgentSessionMessage`. +pub mod agent_session_message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ConsoleIo { + } + /// Nested message and enum types in `ConsoleIO`. + pub mod console_io { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AudioFrame { + #[prost(bytes="vec", tag="1")] + pub data: ::prost::alloc::vec::Vec, + #[prost(uint32, tag="2")] + pub sample_rate: u32, + #[prost(uint32, tag="3")] + pub num_channels: u32, + #[prost(uint32, tag="4")] + pub samples_per_channel: u32, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AudioPlaybackFlush { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AudioPlaybackClear { + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct AudioPlaybackFinished { + } + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Message { + #[prost(message, tag="1")] + AudioInput(console_io::AudioFrame), + #[prost(message, tag="2")] + AudioOutput(console_io::AudioFrame), + #[prost(message, tag="3")] + Event(super::AgentSessionEvent), + #[prost(message, tag="4")] + Request(super::SessionRequest), + #[prost(message, tag="5")] + Response(super::SessionResponse), + #[prost(message, tag="6")] + AudioPlaybackFlush(console_io::AudioPlaybackFlush), + #[prost(message, tag="7")] + AudioPlaybackClear(console_io::AudioPlaybackClear), + #[prost(message, tag="8")] + AudioPlaybackFinished(console_io::AudioPlaybackFinished), + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ChatRole { + Developer = 0, + System = 1, + User = 2, + Assistant = 3, +} +impl ChatRole { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ChatRole::Developer => "DEVELOPER", + ChatRole::System => "SYSTEM", + ChatRole::User => "USER", + ChatRole::Assistant => "ASSISTANT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DEVELOPER" => Some(Self::Developer), + "SYSTEM" => Some(Self::System), + "USER" => Some(Self::User), + "ASSISTANT" => Some(Self::Assistant), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AgentState { + AsInitializing = 0, + AsIdle = 1, + AsListening = 2, + AsThinking = 3, + AsSpeaking = 4, +} +impl AgentState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AgentState::AsInitializing => "AS_INITIALIZING", + AgentState::AsIdle => "AS_IDLE", + AgentState::AsListening => "AS_LISTENING", + AgentState::AsThinking => "AS_THINKING", + AgentState::AsSpeaking => "AS_SPEAKING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "AS_INITIALIZING" => Some(Self::AsInitializing), + "AS_IDLE" => Some(Self::AsIdle), + "AS_LISTENING" => Some(Self::AsListening), + "AS_THINKING" => Some(Self::AsThinking), + "AS_SPEAKING" => Some(Self::AsSpeaking), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum UserState { + UsSpeaking = 0, + UsListening = 1, + UsAway = 2, +} +impl UserState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + UserState::UsSpeaking => "US_SPEAKING", + UserState::UsListening => "US_LISTENING", + UserState::UsAway => "US_AWAY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "US_SPEAKING" => Some(Self::UsSpeaking), + "US_LISTENING" => Some(Self::UsListening), + "US_AWAY" => Some(Self::UsAway), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ToolCallStatus { + TcRunning = 0, + TcDone = 1, + TcError = 2, + TcCancelled = 3, +} +impl ToolCallStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ToolCallStatus::TcRunning => "TC_RUNNING", + ToolCallStatus::TcDone => "TC_DONE", + ToolCallStatus::TcError => "TC_ERROR", + ToolCallStatus::TcCancelled => "TC_CANCELLED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TC_RUNNING" => Some(Self::TcRunning), + "TC_DONE" => Some(Self::TcDone), + "TC_ERROR" => Some(Self::TcError), + "TC_CANCELLED" => Some(Self::TcCancelled), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ToolReplyStatus { + TrScheduled = 0, + TrCompleted = 1, + TrInterrupted = 2, + TrSkipped = 3, +} +impl ToolReplyStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ToolReplyStatus::TrScheduled => "TR_SCHEDULED", + ToolReplyStatus::TrCompleted => "TR_COMPLETED", + ToolReplyStatus::TrInterrupted => "TR_INTERRUPTED", + ToolReplyStatus::TrSkipped => "TR_SKIPPED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TR_SCHEDULED" => Some(Self::TrScheduled), + "TR_COMPLETED" => Some(Self::TrCompleted), + "TR_INTERRUPTED" => Some(Self::TrInterrupted), + "TR_SKIPPED" => Some(Self::TrSkipped), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AmdCategory { + AmdUnknown = 0, + AmdHuman = 1, + AmdMachineIvr = 2, + AmdMachineVm = 3, + AmdMachineUnavailable = 4, + AmdUncertain = 5, +} +impl AmdCategory { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AmdCategory::AmdUnknown => "AMD_UNKNOWN", + AmdCategory::AmdHuman => "AMD_HUMAN", + AmdCategory::AmdMachineIvr => "AMD_MACHINE_IVR", + AmdCategory::AmdMachineVm => "AMD_MACHINE_VM", + AmdCategory::AmdMachineUnavailable => "AMD_MACHINE_UNAVAILABLE", + AmdCategory::AmdUncertain => "AMD_UNCERTAIN", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "AMD_UNKNOWN" => Some(Self::AmdUnknown), + "AMD_HUMAN" => Some(Self::AmdHuman), + "AMD_MACHINE_IVR" => Some(Self::AmdMachineIvr), + "AMD_MACHINE_VM" => Some(Self::AmdMachineVm), + "AMD_MACHINE_UNAVAILABLE" => Some(Self::AmdMachineUnavailable), + "AMD_UNCERTAIN" => Some(Self::AmdUncertain), + _ => None, + } + } +} +/// Request to send a text message to an agent. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageRequest { + #[prost(string, tag="1")] + pub text: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub message_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub session_id: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub agent_name: ::prost::alloc::string::String, + #[prost(string, tag="5")] + pub metadata: ::prost::alloc::string::String, + #[prost(message, optional, tag="6")] + pub session_state: ::core::option::Option, +} +/// Response to a text message request, multiple responses may be sent for a single request until it is complete. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageResponse { + #[prost(string, tag="1")] + pub message_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub session_id: ::prost::alloc::string::String, + #[prost(oneof="text_message_response::Event", tags="3, 4, 5, 6, 7")] + pub event: ::core::option::Option, +} +/// Nested message and enum types in `TextMessageResponse`. +pub mod text_message_response { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Event { + #[prost(message, tag="3")] + Message(super::ChatMessage), + #[prost(message, tag="4")] + FunctionCall(super::FunctionCall), + #[prost(message, tag="5")] + FunctionCallOutput(super::FunctionCallOutput), + #[prost(message, tag="6")] + AgentHandoff(super::AgentHandoff), + #[prost(message, tag="7")] + Complete(super::TextMessageComplete), + } +} +/// Indicates the text message session is complete. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageComplete { + #[prost(oneof="text_message_complete::Result", tags="1, 2")] + pub result: ::core::option::Option, +} +/// Nested message and enum types in `TextMessageComplete`. +pub mod text_message_complete { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Result { + #[prost(message, tag="1")] + SessionState(super::AgentSessionState), + #[prost(message, tag="2")] + Error(super::TextMessageError), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AgentSessionState { + #[prost(uint64, tag="1")] + pub version: u64, + #[prost(oneof="agent_session_state::Data", tags="2, 3")] + pub data: ::core::option::Option, +} +/// Nested message and enum types in `AgentSessionState`. +pub mod agent_session_state { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Data { + #[prost(bytes, tag="2")] + Snapshot(::prost::alloc::vec::Vec), + #[prost(bytes, tag="3")] + Delta(::prost::alloc::vec::Vec), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageError { + #[prost(string, tag="1")] + pub message: ::prost::alloc::string::String, + #[prost(enumeration="TextMessageErrorCode", tag="2")] + pub code: i32, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TextMessageErrorCode { + /// Unexpected internal error + InternalError = 0, + /// Session state not found in cache or version mismatch + SessionStateNotFound = 1, + /// An exception was raised inside the user's text handler + TextHandlerError = 2, + /// The worker process exited before the text session completed + ProcessClosed = 3, +} +impl TextMessageErrorCode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TextMessageErrorCode::InternalError => "INTERNAL_ERROR", + TextMessageErrorCode::SessionStateNotFound => "SESSION_STATE_NOT_FOUND", + TextMessageErrorCode::TextHandlerError => "TEXT_HANDLER_ERROR", + TextMessageErrorCode::ProcessClosed => "PROCESS_CLOSED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "INTERNAL_ERROR" => Some(Self::InternalError), + "SESSION_STATE_NOT_FOUND" => Some(Self::SessionStateNotFound), + "TEXT_HANDLER_ERROR" => Some(Self::TextHandlerError), + "PROCESS_CLOSED" => Some(Self::ProcessClosed), + _ => None, + } + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionSettings { + #[prost(uint32, tag="1")] + pub sample_rate: u32, + #[prost(enumeration="AudioEncoding", tag="2")] + pub encoding: i32, + #[prost(oneof="session_settings::TypeSettings", tags="3, 4")] + pub type_settings: ::core::option::Option, +} +/// Nested message and enum types in `SessionSettings`. +pub mod session_settings { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum TypeSettings { + #[prost(message, tag="3")] + EotSettings(super::EotSettings), + #[prost(message, tag="4")] + InterruptionSettings(super::InterruptionSettings), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceError { + #[prost(string, tag="1")] + pub message: ::prost::alloc::string::String, + /// error code follows the HTTP status code convention + /// 4xx for client errors + /// 5xx for server errors + #[prost(uint32, tag="2")] + pub code: u32, +} +// --- End of Turn (EOT) Settings --- + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotSettings { + #[prost(message, optional, tag="1")] + pub detection_interval: ::core::option::Option<::pbjson_types::Duration>, +} +// --- Interruption Settings --- + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterruptionSettings { + /// detection threshold in range \[0.0, 1.0\]; higher values are less sensitive + #[prost(float, tag="1")] + pub threshold: f32, + /// minimum number of frames with probability greater than threshold to trigger an interruption + #[prost(uint32, tag="2")] + pub min_frames: u32, + #[prost(message, optional, tag="3")] + pub max_audio_duration: ::core::option::Option<::pbjson_types::Duration>, + #[prost(message, optional, tag="4")] + pub audio_prefix_duration: ::core::option::Option<::pbjson_types::Duration>, + #[prost(message, optional, tag="5")] + pub detection_interval: ::core::option::Option<::pbjson_types::Duration>, +} +// --- Client -> Server --- + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionCreate { + #[prost(message, optional, tag="1")] + pub settings: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InputAudio { + #[prost(bytes="vec", tag="1")] + pub audio: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(uint32, tag="3")] + pub num_samples: u32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotInputChatContext { + #[prost(message, repeated, tag="1")] + pub messages: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionFlush { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionClose { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceStart { + #[prost(string, tag="1")] + pub request_id: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceStop { + #[prost(string, tag="1")] + pub request_id: ::prost::alloc::string::String, +} +/// audio buffer sentinel messages +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BufferStart { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BufferStop { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientMessage { + #[prost(message, optional, tag="1")] + pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(oneof="client_message::Message", tags="2, 3, 4, 5, 6, 7, 8, 9, 10")] + pub message: ::core::option::Option, +} +/// Nested message and enum types in `ClientMessage`. +pub mod client_message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Message { + #[prost(message, tag="2")] + SessionCreate(super::SessionCreate), + #[prost(message, tag="3")] + InputAudio(super::InputAudio), + #[prost(message, tag="4")] + SessionFlush(super::SessionFlush), + #[prost(message, tag="5")] + SessionClose(super::SessionClose), + #[prost(message, tag="6")] + InferenceStart(super::InferenceStart), + #[prost(message, tag="7")] + InferenceStop(super::InferenceStop), + #[prost(message, tag="8")] + BufferStart(super::BufferStart), + #[prost(message, tag="9")] + BufferStop(super::BufferStop), + /// only for end of turn + #[prost(message, tag="10")] + EotInputChatContext(super::EotInputChatContext), + } +} +// --- Server -> Model --- +// +// NOTE: these messages are not currently used on the wire between the model +// server (infserve) and the gateway; that communication is presently done via +// JSON requests and responses. They are kept here for reference and future use. + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotInferenceRequest { + #[prost(bytes="vec", tag="1")] + pub audio: ::prost::alloc::vec::Vec, + #[prost(string, tag="2")] + pub assistant_text: ::prost::alloc::string::String, + #[prost(enumeration="AudioEncoding", tag="3")] + pub encoding: i32, + #[prost(uint32, tag="4")] + pub sample_rate: u32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterruptionInferenceRequest { + #[prost(bytes="vec", tag="1")] + pub audio: ::prost::alloc::vec::Vec, + #[prost(enumeration="AudioEncoding", tag="2")] + pub encoding: i32, + #[prost(uint32, tag="3")] + pub sample_rate: u32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceRequest { + #[prost(oneof="inference_request::Request", tags="1, 2")] + pub request: ::core::option::Option, +} +/// Nested message and enum types in `InferenceRequest`. +pub mod inference_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Request { + #[prost(message, tag="1")] + EotInferenceRequest(super::EotInferenceRequest), + #[prost(message, tag="2")] + InterruptionInferenceRequest(super::InterruptionInferenceRequest), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceStats { + /// proxy -> model: audio window timestamps + #[prost(message, optional, tag="1")] + pub earliest_client_created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(message, optional, tag="2")] + pub latest_client_created_at: ::core::option::Option<::pbjson_types::Timestamp>, + /// proxy side e2e latency (proxy send -> proxy receive) + #[prost(message, optional, tag="3")] + pub client_e2e_latency: ::core::option::Option<::pbjson_types::Duration>, + /// model side e2e latency (model endpoint receive -> model endpoint return) + #[prost(message, optional, tag="4")] + pub server_e2e_latency: ::core::option::Option<::pbjson_types::Duration>, + /// model side inference stats + #[prost(message, optional, tag="5")] + pub preprocessing_duration: ::core::option::Option<::pbjson_types::Duration>, + #[prost(message, optional, tag="6")] + pub inference_duration: ::core::option::Option<::pbjson_types::Duration>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotInferenceResponse { + #[prost(float, tag="1")] + pub probability: f32, + #[prost(message, optional, tag="2")] + pub stats: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterruptionInferenceResponse { + #[prost(bool, tag="1")] + pub is_interruption: bool, + /// per frame probabilities + #[prost(float, repeated, tag="2")] + pub probabilities: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub stats: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceResponse { + #[prost(oneof="inference_response::Response", tags="1, 2")] + pub response: ::core::option::Option, +} +/// Nested message and enum types in `InferenceResponse`. +pub mod inference_response { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(message, tag="1")] + EotInferenceResponse(super::EotInferenceResponse), + #[prost(message, tag="2")] + InterruptionInferenceResponse(super::InterruptionInferenceResponse), + } +} +// --- Server -> Client --- + +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionCreated { + /// Server-recommended default detection thresholds keyed by language code + /// (e.g. "en", "es"). The threshold semantics match the session type: EOT + /// probability threshold for EOT sessions, interruption threshold for + /// barge-in sessions. + #[prost(map="string, float", tag="1")] + pub default_thresholds: ::std::collections::HashMap<::prost::alloc::string::String, f32>, + /// Catch-all default applied to languages not present in default_thresholds. + #[prost(float, tag="2")] + pub default_threshold: f32, + /// same structure, but for backchannel + #[prost(map="string, float", tag="3")] + pub default_backchannel_thresholds: ::std::collections::HashMap<::prost::alloc::string::String, f32>, + #[prost(float, tag="4")] + pub default_backchannel_threshold: f32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceStarted { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InferenceStopped { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SessionClosed { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EotPrediction { + #[prost(float, tag="1")] + pub probability: f32, + #[prost(message, optional, tag="2")] + pub inference_stats: ::core::option::Option, + #[prost(enumeration="eot_prediction::EotBackend", tag="3")] + pub backend: i32, + #[prost(float, tag="4")] + pub backchannel_probability: f32, +} +/// Nested message and enum types in `EotPrediction`. +pub mod eot_prediction { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum EotBackend { + Unknown = 0, + Multimodal = 1, + Text = 2, + } + impl EotBackend { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + EotBackend::Unknown => "EOT_BACKEND_UNKNOWN", + EotBackend::Multimodal => "EOT_BACKEND_MULTIMODAL", + EotBackend::Text => "EOT_BACKEND_TEXT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "EOT_BACKEND_UNKNOWN" => Some(Self::Unknown), + "EOT_BACKEND_MULTIMODAL" => Some(Self::Multimodal), + "EOT_BACKEND_TEXT" => Some(Self::Text), + _ => None, + } + } + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterruptionPrediction { + #[prost(bool, tag="1")] + pub is_interruption: bool, + #[prost(float, repeated, tag="2")] + pub probabilities: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub inference_stats: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ServerMessage { + #[prost(message, optional, tag="1")] + pub server_created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(string, optional, tag="2")] + pub request_id: ::core::option::Option<::prost::alloc::string::String>, + /// echoes the client-side created_at timestamp + #[prost(message, optional, tag="3")] + pub client_created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(oneof="server_message::Message", tags="4, 5, 6, 7, 8, 9, 10")] + pub message: ::core::option::Option, +} +/// Nested message and enum types in `ServerMessage`. +pub mod server_message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Message { + #[prost(message, tag="4")] + SessionCreated(super::SessionCreated), + #[prost(message, tag="5")] + InferenceStarted(super::InferenceStarted), + #[prost(message, tag="6")] + InferenceStopped(super::InferenceStopped), + #[prost(message, tag="7")] + SessionClosed(super::SessionClosed), + #[prost(message, tag="8")] + Error(super::InferenceError), + #[prost(message, tag="9")] + EotPrediction(super::EotPrediction), + #[prost(message, tag="10")] + InterruptionPrediction(super::InterruptionPrediction), + } +} +// --- Shared Types --- + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AudioEncoding { + PcmS16le = 0, + Opus = 1, +} +impl AudioEncoding { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AudioEncoding::PcmS16le => "AUDIO_ENCODING_PCM_S16LE", + AudioEncoding::Opus => "AUDIO_ENCODING_OPUS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "AUDIO_ENCODING_PCM_S16LE" => Some(Self::PcmS16le), + "AUDIO_ENCODING_OPUS" => Some(Self::Opus), + _ => None, + } + } +} +include!("livekit.agent.serde.rs"); +// @@protoc_insertion_point(module) diff --git a/livekit-protocol/src/livekit.agent.serde.rs b/livekit-protocol/src/livekit.agent.serde.rs new file mode 100644 index 000000000..fd107811e --- /dev/null +++ b/livekit-protocol/src/livekit.agent.serde.rs @@ -0,0 +1,14164 @@ +// @generated +impl serde::Serialize for AgentConfigUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.instructions.is_some() { + len += 1; + } + if !self.tools_added.is_empty() { + len += 1; + } + if !self.tools_removed.is_empty() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentConfigUpdate", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.instructions.as_ref() { + struct_ser.serialize_field("instructions", v)?; + } + if !self.tools_added.is_empty() { + struct_ser.serialize_field("toolsAdded", &self.tools_added)?; + } + if !self.tools_removed.is_empty() { + struct_ser.serialize_field("toolsRemoved", &self.tools_removed)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentConfigUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "instructions", + "tools_added", + "toolsAdded", + "tools_removed", + "toolsRemoved", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Instructions, + ToolsAdded, + ToolsRemoved, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "instructions" => Ok(GeneratedField::Instructions), + "toolsAdded" | "tools_added" => Ok(GeneratedField::ToolsAdded), + "toolsRemoved" | "tools_removed" => Ok(GeneratedField::ToolsRemoved), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentConfigUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentConfigUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut instructions__ = None; + let mut tools_added__ = None; + let mut tools_removed__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Instructions => { + if instructions__.is_some() { + return Err(serde::de::Error::duplicate_field("instructions")); + } + instructions__ = map_.next_value()?; + } + GeneratedField::ToolsAdded => { + if tools_added__.is_some() { + return Err(serde::de::Error::duplicate_field("toolsAdded")); + } + tools_added__ = Some(map_.next_value()?); + } + GeneratedField::ToolsRemoved => { + if tools_removed__.is_some() { + return Err(serde::de::Error::duplicate_field("toolsRemoved")); + } + tools_removed__ = Some(map_.next_value()?); + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentConfigUpdate { + id: id__.unwrap_or_default(), + instructions: instructions__, + tools_added: tools_added__.unwrap_or_default(), + tools_removed: tools_removed__.unwrap_or_default(), + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentConfigUpdate", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentDevMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.message.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentDevMessage", len)?; + if let Some(v) = self.message.as_ref() { + match v { + agent_dev_message::Message::GetRunningJobsRequest(v) => { + struct_ser.serialize_field("getRunningJobsRequest", v)?; + } + agent_dev_message::Message::GetRunningJobsResponse(v) => { + struct_ser.serialize_field("getRunningJobsResponse", v)?; + } + agent_dev_message::Message::ServerInfo(v) => { + struct_ser.serialize_field("serverInfo", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentDevMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "get_running_jobs_request", + "getRunningJobsRequest", + "get_running_jobs_response", + "getRunningJobsResponse", + "server_info", + "serverInfo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + GetRunningJobsRequest, + GetRunningJobsResponse, + ServerInfo, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "getRunningJobsRequest" | "get_running_jobs_request" => Ok(GeneratedField::GetRunningJobsRequest), + "getRunningJobsResponse" | "get_running_jobs_response" => Ok(GeneratedField::GetRunningJobsResponse), + "serverInfo" | "server_info" => Ok(GeneratedField::ServerInfo), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentDevMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentDevMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::GetRunningJobsRequest => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("getRunningJobsRequest")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_dev_message::Message::GetRunningJobsRequest) +; + } + GeneratedField::GetRunningJobsResponse => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("getRunningJobsResponse")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_dev_message::Message::GetRunningJobsResponse) +; + } + GeneratedField::ServerInfo => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("serverInfo")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_dev_message::Message::ServerInfo) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentDevMessage { + message: message__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentDevMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentHandoff { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.old_agent_id.is_some() { + len += 1; + } + if !self.new_agent_id.is_empty() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentHandoff", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.old_agent_id.as_ref() { + struct_ser.serialize_field("oldAgentId", v)?; + } + if !self.new_agent_id.is_empty() { + struct_ser.serialize_field("newAgentId", &self.new_agent_id)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentHandoff { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "old_agent_id", + "oldAgentId", + "new_agent_id", + "newAgentId", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + OldAgentId, + NewAgentId, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "oldAgentId" | "old_agent_id" => Ok(GeneratedField::OldAgentId), + "newAgentId" | "new_agent_id" => Ok(GeneratedField::NewAgentId), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentHandoff; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentHandoff") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut old_agent_id__ = None; + let mut new_agent_id__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::OldAgentId => { + if old_agent_id__.is_some() { + return Err(serde::de::Error::duplicate_field("oldAgentId")); + } + old_agent_id__ = map_.next_value()?; + } + GeneratedField::NewAgentId => { + if new_agent_id__.is_some() { + return Err(serde::de::Error::duplicate_field("newAgentId")); + } + new_agent_id__ = Some(map_.next_value()?); + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentHandoff { + id: id__.unwrap_or_default(), + old_agent_id: old_agent_id__, + new_agent_id: new_agent_id__.unwrap_or_default(), + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentHandoff", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentSessionEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_at.is_some() { + len += 1; + } + if self.event.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent", len)?; + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + if let Some(v) = self.event.as_ref() { + match v { + agent_session_event::Event::AgentStateChanged(v) => { + struct_ser.serialize_field("agentStateChanged", v)?; + } + agent_session_event::Event::UserStateChanged(v) => { + struct_ser.serialize_field("userStateChanged", v)?; + } + agent_session_event::Event::ConversationItemAdded(v) => { + struct_ser.serialize_field("conversationItemAdded", v)?; + } + agent_session_event::Event::UserInputTranscribed(v) => { + struct_ser.serialize_field("userInputTranscribed", v)?; + } + agent_session_event::Event::FunctionToolsExecuted(v) => { + struct_ser.serialize_field("functionToolsExecuted", v)?; + } + agent_session_event::Event::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + agent_session_event::Event::OverlappingSpeech(v) => { + struct_ser.serialize_field("overlappingSpeech", v)?; + } + agent_session_event::Event::SessionUsageUpdated(v) => { + struct_ser.serialize_field("sessionUsageUpdated", v)?; + } + agent_session_event::Event::AmdPrediction(v) => { + struct_ser.serialize_field("amdPrediction", v)?; + } + agent_session_event::Event::EotPrediction(v) => { + struct_ser.serialize_field("eotPrediction", v)?; + } + agent_session_event::Event::FunctionToolsStarted(v) => { + struct_ser.serialize_field("functionToolsStarted", v)?; + } + agent_session_event::Event::DebugMessage(v) => { + struct_ser.serialize_field("debugMessage", v)?; + } + agent_session_event::Event::ToolExecutionUpdated(v) => { + struct_ser.serialize_field("toolExecutionUpdated", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentSessionEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_at", + "createdAt", + "agent_state_changed", + "agentStateChanged", + "user_state_changed", + "userStateChanged", + "conversation_item_added", + "conversationItemAdded", + "user_input_transcribed", + "userInputTranscribed", + "function_tools_executed", + "functionToolsExecuted", + "error", + "overlapping_speech", + "overlappingSpeech", + "session_usage_updated", + "sessionUsageUpdated", + "amd_prediction", + "amdPrediction", + "eot_prediction", + "eotPrediction", + "function_tools_started", + "functionToolsStarted", + "debug_message", + "debugMessage", + "tool_execution_updated", + "toolExecutionUpdated", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedAt, + AgentStateChanged, + UserStateChanged, + ConversationItemAdded, + UserInputTranscribed, + FunctionToolsExecuted, + Error, + OverlappingSpeech, + SessionUsageUpdated, + AmdPrediction, + EotPrediction, + FunctionToolsStarted, + DebugMessage, + ToolExecutionUpdated, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + "agentStateChanged" | "agent_state_changed" => Ok(GeneratedField::AgentStateChanged), + "userStateChanged" | "user_state_changed" => Ok(GeneratedField::UserStateChanged), + "conversationItemAdded" | "conversation_item_added" => Ok(GeneratedField::ConversationItemAdded), + "userInputTranscribed" | "user_input_transcribed" => Ok(GeneratedField::UserInputTranscribed), + "functionToolsExecuted" | "function_tools_executed" => Ok(GeneratedField::FunctionToolsExecuted), + "error" => Ok(GeneratedField::Error), + "overlappingSpeech" | "overlapping_speech" => Ok(GeneratedField::OverlappingSpeech), + "sessionUsageUpdated" | "session_usage_updated" => Ok(GeneratedField::SessionUsageUpdated), + "amdPrediction" | "amd_prediction" => Ok(GeneratedField::AmdPrediction), + "eotPrediction" | "eot_prediction" => Ok(GeneratedField::EotPrediction), + "functionToolsStarted" | "function_tools_started" => Ok(GeneratedField::FunctionToolsStarted), + "debugMessage" | "debug_message" => Ok(GeneratedField::DebugMessage), + "toolExecutionUpdated" | "tool_execution_updated" => Ok(GeneratedField::ToolExecutionUpdated), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentSessionEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_at__ = None; + let mut event__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::AgentStateChanged => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("agentStateChanged")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::AgentStateChanged) +; + } + GeneratedField::UserStateChanged => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("userStateChanged")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::UserStateChanged) +; + } + GeneratedField::ConversationItemAdded => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("conversationItemAdded")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::ConversationItemAdded) +; + } + GeneratedField::UserInputTranscribed => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("userInputTranscribed")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::UserInputTranscribed) +; + } + GeneratedField::FunctionToolsExecuted => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("functionToolsExecuted")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::FunctionToolsExecuted) +; + } + GeneratedField::Error => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::Error) +; + } + GeneratedField::OverlappingSpeech => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("overlappingSpeech")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::OverlappingSpeech) +; + } + GeneratedField::SessionUsageUpdated => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionUsageUpdated")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::SessionUsageUpdated) +; + } + GeneratedField::AmdPrediction => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("amdPrediction")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::AmdPrediction) +; + } + GeneratedField::EotPrediction => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("eotPrediction")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::EotPrediction) +; + } + GeneratedField::FunctionToolsStarted => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("functionToolsStarted")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::FunctionToolsStarted) +; + } + GeneratedField::DebugMessage => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("debugMessage")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::DebugMessage) +; + } + GeneratedField::ToolExecutionUpdated => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("toolExecutionUpdated")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::Event::ToolExecutionUpdated) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentSessionEvent { + created_at: created_at__, + event: event__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::AgentStateChanged { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.old_state != 0 { + len += 1; + } + if self.new_state != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.AgentStateChanged", len)?; + if self.old_state != 0 { + let v = AgentState::try_from(self.old_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.old_state)))?; + struct_ser.serialize_field("oldState", &v)?; + } + if self.new_state != 0 { + let v = AgentState::try_from(self.new_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.new_state)))?; + struct_ser.serialize_field("newState", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::AgentStateChanged { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "old_state", + "oldState", + "new_state", + "newState", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OldState, + NewState, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "oldState" | "old_state" => Ok(GeneratedField::OldState), + "newState" | "new_state" => Ok(GeneratedField::NewState), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::AgentStateChanged; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.AgentStateChanged") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut old_state__ = None; + let mut new_state__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::OldState => { + if old_state__.is_some() { + return Err(serde::de::Error::duplicate_field("oldState")); + } + old_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::NewState => { + if new_state__.is_some() { + return Err(serde::de::Error::duplicate_field("newState")); + } + new_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::AgentStateChanged { + old_state: old_state__.unwrap_or_default(), + new_state: new_state__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.AgentStateChanged", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::AmdPrediction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.speech_duration.is_some() { + len += 1; + } + if self.category != 0 { + len += 1; + } + if !self.reason.is_empty() { + len += 1; + } + if !self.transcript.is_empty() { + len += 1; + } + if self.delay.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.AmdPrediction", len)?; + if let Some(v) = self.speech_duration.as_ref() { + struct_ser.serialize_field("speechDuration", v)?; + } + if self.category != 0 { + let v = AmdCategory::try_from(self.category) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.category)))?; + struct_ser.serialize_field("category", &v)?; + } + if !self.reason.is_empty() { + struct_ser.serialize_field("reason", &self.reason)?; + } + if !self.transcript.is_empty() { + struct_ser.serialize_field("transcript", &self.transcript)?; + } + if let Some(v) = self.delay.as_ref() { + struct_ser.serialize_field("delay", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::AmdPrediction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "speech_duration", + "speechDuration", + "category", + "reason", + "transcript", + "delay", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SpeechDuration, + Category, + Reason, + Transcript, + Delay, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "speechDuration" | "speech_duration" => Ok(GeneratedField::SpeechDuration), + "category" => Ok(GeneratedField::Category), + "reason" => Ok(GeneratedField::Reason), + "transcript" => Ok(GeneratedField::Transcript), + "delay" => Ok(GeneratedField::Delay), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::AmdPrediction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.AmdPrediction") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut speech_duration__ = None; + let mut category__ = None; + let mut reason__ = None; + let mut transcript__ = None; + let mut delay__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SpeechDuration => { + if speech_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("speechDuration")); + } + speech_duration__ = map_.next_value()?; + } + GeneratedField::Category => { + if category__.is_some() { + return Err(serde::de::Error::duplicate_field("category")); + } + category__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Reason => { + if reason__.is_some() { + return Err(serde::de::Error::duplicate_field("reason")); + } + reason__ = Some(map_.next_value()?); + } + GeneratedField::Transcript => { + if transcript__.is_some() { + return Err(serde::de::Error::duplicate_field("transcript")); + } + transcript__ = Some(map_.next_value()?); + } + GeneratedField::Delay => { + if delay__.is_some() { + return Err(serde::de::Error::duplicate_field("delay")); + } + delay__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::AmdPrediction { + speech_duration: speech_duration__, + category: category__.unwrap_or_default(), + reason: reason__.unwrap_or_default(), + transcript: transcript__.unwrap_or_default(), + delay: delay__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.AmdPrediction", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::ConversationItemAdded { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.item.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ConversationItemAdded", len)?; + if let Some(v) = self.item.as_ref() { + struct_ser.serialize_field("item", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::ConversationItemAdded { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "item", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Item, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "item" => Ok(GeneratedField::Item), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::ConversationItemAdded; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ConversationItemAdded") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut item__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Item => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("item")); + } + item__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::ConversationItemAdded { + item: item__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ConversationItemAdded", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::EotPrediction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.probability != 0. { + len += 1; + } + if self.threshold != 0. { + len += 1; + } + if self.inference_duration.is_some() { + len += 1; + } + if self.delay.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.EotPrediction", len)?; + if self.probability != 0. { + struct_ser.serialize_field("probability", &self.probability)?; + } + if self.threshold != 0. { + struct_ser.serialize_field("threshold", &self.threshold)?; + } + if let Some(v) = self.inference_duration.as_ref() { + struct_ser.serialize_field("inferenceDuration", v)?; + } + if let Some(v) = self.delay.as_ref() { + struct_ser.serialize_field("delay", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::EotPrediction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "probability", + "threshold", + "inference_duration", + "inferenceDuration", + "delay", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Probability, + Threshold, + InferenceDuration, + Delay, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "probability" => Ok(GeneratedField::Probability), + "threshold" => Ok(GeneratedField::Threshold), + "inferenceDuration" | "inference_duration" => Ok(GeneratedField::InferenceDuration), + "delay" => Ok(GeneratedField::Delay), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::EotPrediction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.EotPrediction") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut probability__ = None; + let mut threshold__ = None; + let mut inference_duration__ = None; + let mut delay__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Probability => { + if probability__.is_some() { + return Err(serde::de::Error::duplicate_field("probability")); + } + probability__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Threshold => { + if threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("threshold")); + } + threshold__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InferenceDuration => { + if inference_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceDuration")); + } + inference_duration__ = map_.next_value()?; + } + GeneratedField::Delay => { + if delay__.is_some() { + return Err(serde::de::Error::duplicate_field("delay")); + } + delay__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::EotPrediction { + probability: probability__.unwrap_or_default(), + threshold: threshold__.unwrap_or_default(), + inference_duration: inference_duration__, + delay: delay__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.EotPrediction", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::Error { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.Error", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::Error { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "message" => Ok(GeneratedField::Message), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::Error; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.Error") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::Error { + message: message__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.Error", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::FunctionToolsExecuted { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.function_calls.is_empty() { + len += 1; + } + if !self.function_call_outputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.FunctionToolsExecuted", len)?; + if !self.function_calls.is_empty() { + struct_ser.serialize_field("functionCalls", &self.function_calls)?; + } + if !self.function_call_outputs.is_empty() { + struct_ser.serialize_field("functionCallOutputs", &self.function_call_outputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::FunctionToolsExecuted { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "function_calls", + "functionCalls", + "function_call_outputs", + "functionCallOutputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunctionCalls, + FunctionCallOutputs, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "functionCalls" | "function_calls" => Ok(GeneratedField::FunctionCalls), + "functionCallOutputs" | "function_call_outputs" => Ok(GeneratedField::FunctionCallOutputs), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::FunctionToolsExecuted; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.FunctionToolsExecuted") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut function_calls__ = None; + let mut function_call_outputs__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::FunctionCalls => { + if function_calls__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCalls")); + } + function_calls__ = Some(map_.next_value()?); + } + GeneratedField::FunctionCallOutputs => { + if function_call_outputs__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCallOutputs")); + } + function_call_outputs__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::FunctionToolsExecuted { + function_calls: function_calls__.unwrap_or_default(), + function_call_outputs: function_call_outputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.FunctionToolsExecuted", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::FunctionToolsStarted { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.function_calls.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.FunctionToolsStarted", len)?; + if !self.function_calls.is_empty() { + struct_ser.serialize_field("functionCalls", &self.function_calls)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::FunctionToolsStarted { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "function_calls", + "functionCalls", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunctionCalls, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "functionCalls" | "function_calls" => Ok(GeneratedField::FunctionCalls), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::FunctionToolsStarted; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.FunctionToolsStarted") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut function_calls__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::FunctionCalls => { + if function_calls__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCalls")); + } + function_calls__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::FunctionToolsStarted { + function_calls: function_calls__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.FunctionToolsStarted", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::OverlappingSpeech { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.is_interruption { + len += 1; + } + if self.overlap_started_at.is_some() { + len += 1; + } + if self.detection_delay != 0. { + len += 1; + } + if self.detected_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.OverlappingSpeech", len)?; + if self.is_interruption { + struct_ser.serialize_field("isInterruption", &self.is_interruption)?; + } + if let Some(v) = self.overlap_started_at.as_ref() { + struct_ser.serialize_field("overlapStartedAt", v)?; + } + if self.detection_delay != 0. { + struct_ser.serialize_field("detectionDelay", &self.detection_delay)?; + } + if let Some(v) = self.detected_at.as_ref() { + struct_ser.serialize_field("detectedAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::OverlappingSpeech { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "is_interruption", + "isInterruption", + "overlap_started_at", + "overlapStartedAt", + "detection_delay", + "detectionDelay", + "detected_at", + "detectedAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IsInterruption, + OverlapStartedAt, + DetectionDelay, + DetectedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "isInterruption" | "is_interruption" => Ok(GeneratedField::IsInterruption), + "overlapStartedAt" | "overlap_started_at" => Ok(GeneratedField::OverlapStartedAt), + "detectionDelay" | "detection_delay" => Ok(GeneratedField::DetectionDelay), + "detectedAt" | "detected_at" => Ok(GeneratedField::DetectedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::OverlappingSpeech; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.OverlappingSpeech") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut is_interruption__ = None; + let mut overlap_started_at__ = None; + let mut detection_delay__ = None; + let mut detected_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::IsInterruption => { + if is_interruption__.is_some() { + return Err(serde::de::Error::duplicate_field("isInterruption")); + } + is_interruption__ = Some(map_.next_value()?); + } + GeneratedField::OverlapStartedAt => { + if overlap_started_at__.is_some() { + return Err(serde::de::Error::duplicate_field("overlapStartedAt")); + } + overlap_started_at__ = map_.next_value()?; + } + GeneratedField::DetectionDelay => { + if detection_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("detectionDelay")); + } + detection_delay__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::DetectedAt => { + if detected_at__.is_some() { + return Err(serde::de::Error::duplicate_field("detectedAt")); + } + detected_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::OverlappingSpeech { + is_interruption: is_interruption__.unwrap_or_default(), + overlap_started_at: overlap_started_at__, + detection_delay: detection_delay__.unwrap_or_default(), + detected_at: detected_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.OverlappingSpeech", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::SessionUsageUpdated { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.usage.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.SessionUsageUpdated", len)?; + if let Some(v) = self.usage.as_ref() { + struct_ser.serialize_field("usage", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::SessionUsageUpdated { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "usage", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Usage, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "usage" => Ok(GeneratedField::Usage), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::SessionUsageUpdated; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.SessionUsageUpdated") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut usage__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Usage => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("usage")); + } + usage__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::SessionUsageUpdated { + usage: usage__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.SessionUsageUpdated", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::ToolExecutionUpdated { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.update.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated", len)?; + if let Some(v) = self.update.as_ref() { + match v { + agent_session_event::tool_execution_updated::Update::Started(v) => { + struct_ser.serialize_field("started", v)?; + } + agent_session_event::tool_execution_updated::Update::CallUpdated(v) => { + struct_ser.serialize_field("callUpdated", v)?; + } + agent_session_event::tool_execution_updated::Update::ReplyUpdated(v) => { + struct_ser.serialize_field("replyUpdated", v)?; + } + agent_session_event::tool_execution_updated::Update::Ended(v) => { + struct_ser.serialize_field("ended", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::ToolExecutionUpdated { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "started", + "call_updated", + "callUpdated", + "reply_updated", + "replyUpdated", + "ended", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Started, + CallUpdated, + ReplyUpdated, + Ended, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "started" => Ok(GeneratedField::Started), + "callUpdated" | "call_updated" => Ok(GeneratedField::CallUpdated), + "replyUpdated" | "reply_updated" => Ok(GeneratedField::ReplyUpdated), + "ended" => Ok(GeneratedField::Ended), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::ToolExecutionUpdated; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ToolExecutionUpdated") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut update__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Started => { + if update__.is_some() { + return Err(serde::de::Error::duplicate_field("started")); + } + update__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::tool_execution_updated::Update::Started) +; + } + GeneratedField::CallUpdated => { + if update__.is_some() { + return Err(serde::de::Error::duplicate_field("callUpdated")); + } + update__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::tool_execution_updated::Update::CallUpdated) +; + } + GeneratedField::ReplyUpdated => { + if update__.is_some() { + return Err(serde::de::Error::duplicate_field("replyUpdated")); + } + update__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::tool_execution_updated::Update::ReplyUpdated) +; + } + GeneratedField::Ended => { + if update__.is_some() { + return Err(serde::de::Error::duplicate_field("ended")); + } + update__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_event::tool_execution_updated::Update::Ended) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::ToolExecutionUpdated { + update: update__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::tool_execution_updated::CallUpdated { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.call_id.is_empty() { + len += 1; + } + if !self.message.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.CallUpdated", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.call_id.is_empty() { + struct_ser.serialize_field("callId", &self.call_id)?; + } + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::tool_execution_updated::CallUpdated { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "call_id", + "callId", + "message", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + CallId, + Message, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "callId" | "call_id" => Ok(GeneratedField::CallId), + "message" => Ok(GeneratedField::Message), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::tool_execution_updated::CallUpdated; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ToolExecutionUpdated.CallUpdated") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut call_id__ = None; + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::CallId => { + if call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("callId")); + } + call_id__ = Some(map_.next_value()?); + } + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::tool_execution_updated::CallUpdated { + id: id__.unwrap_or_default(), + call_id: call_id__.unwrap_or_default(), + message: message__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.CallUpdated", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::tool_execution_updated::Ended { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.call_id.is_empty() { + len += 1; + } + if self.message.is_some() { + len += 1; + } + if self.status != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Ended", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.call_id.is_empty() { + struct_ser.serialize_field("callId", &self.call_id)?; + } + if let Some(v) = self.message.as_ref() { + struct_ser.serialize_field("message", v)?; + } + if self.status != 0 { + let v = ToolCallStatus::try_from(self.status) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?; + struct_ser.serialize_field("status", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::tool_execution_updated::Ended { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "call_id", + "callId", + "message", + "status", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + CallId, + Message, + Status, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "callId" | "call_id" => Ok(GeneratedField::CallId), + "message" => Ok(GeneratedField::Message), + "status" => Ok(GeneratedField::Status), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::tool_execution_updated::Ended; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Ended") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut call_id__ = None; + let mut message__ = None; + let mut status__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::CallId => { + if call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("callId")); + } + call_id__ = Some(map_.next_value()?); + } + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = map_.next_value()?; + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::tool_execution_updated::Ended { + id: id__.unwrap_or_default(), + call_id: call_id__.unwrap_or_default(), + message: message__, + status: status__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Ended", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::tool_execution_updated::ReplyUpdated { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.update_ids.is_empty() { + len += 1; + } + if self.status != 0 { + len += 1; + } + if !self.speech_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.ReplyUpdated", len)?; + if !self.update_ids.is_empty() { + struct_ser.serialize_field("updateIds", &self.update_ids)?; + } + if self.status != 0 { + let v = ToolReplyStatus::try_from(self.status) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?; + struct_ser.serialize_field("status", &v)?; + } + if !self.speech_id.is_empty() { + struct_ser.serialize_field("speechId", &self.speech_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::tool_execution_updated::ReplyUpdated { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "update_ids", + "updateIds", + "status", + "speech_id", + "speechId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + UpdateIds, + Status, + SpeechId, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "updateIds" | "update_ids" => Ok(GeneratedField::UpdateIds), + "status" => Ok(GeneratedField::Status), + "speechId" | "speech_id" => Ok(GeneratedField::SpeechId), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::tool_execution_updated::ReplyUpdated; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ToolExecutionUpdated.ReplyUpdated") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut update_ids__ = None; + let mut status__ = None; + let mut speech_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::UpdateIds => { + if update_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("updateIds")); + } + update_ids__ = Some(map_.next_value()?); + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SpeechId => { + if speech_id__.is_some() { + return Err(serde::de::Error::duplicate_field("speechId")); + } + speech_id__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::tool_execution_updated::ReplyUpdated { + update_ids: update_ids__.unwrap_or_default(), + status: status__.unwrap_or_default(), + speech_id: speech_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.ReplyUpdated", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::tool_execution_updated::Started { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.function_call.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Started", len)?; + if let Some(v) = self.function_call.as_ref() { + struct_ser.serialize_field("functionCall", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::tool_execution_updated::Started { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "function_call", + "functionCall", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunctionCall, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "functionCall" | "function_call" => Ok(GeneratedField::FunctionCall), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::tool_execution_updated::Started; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Started") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut function_call__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::FunctionCall => { + if function_call__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCall")); + } + function_call__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::tool_execution_updated::Started { + function_call: function_call__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.ToolExecutionUpdated.Started", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::UserInputTranscribed { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.transcript.is_empty() { + len += 1; + } + if self.is_final { + len += 1; + } + if self.language.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.UserInputTranscribed", len)?; + if !self.transcript.is_empty() { + struct_ser.serialize_field("transcript", &self.transcript)?; + } + if self.is_final { + struct_ser.serialize_field("isFinal", &self.is_final)?; + } + if let Some(v) = self.language.as_ref() { + struct_ser.serialize_field("language", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::UserInputTranscribed { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "transcript", + "is_final", + "isFinal", + "language", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Transcript, + IsFinal, + Language, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "transcript" => Ok(GeneratedField::Transcript), + "isFinal" | "is_final" => Ok(GeneratedField::IsFinal), + "language" => Ok(GeneratedField::Language), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::UserInputTranscribed; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.UserInputTranscribed") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut transcript__ = None; + let mut is_final__ = None; + let mut language__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Transcript => { + if transcript__.is_some() { + return Err(serde::de::Error::duplicate_field("transcript")); + } + transcript__ = Some(map_.next_value()?); + } + GeneratedField::IsFinal => { + if is_final__.is_some() { + return Err(serde::de::Error::duplicate_field("isFinal")); + } + is_final__ = Some(map_.next_value()?); + } + GeneratedField::Language => { + if language__.is_some() { + return Err(serde::de::Error::duplicate_field("language")); + } + language__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::UserInputTranscribed { + transcript: transcript__.unwrap_or_default(), + is_final: is_final__.unwrap_or_default(), + language: language__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.UserInputTranscribed", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_event::UserStateChanged { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.old_state != 0 { + len += 1; + } + if self.new_state != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionEvent.UserStateChanged", len)?; + if self.old_state != 0 { + let v = UserState::try_from(self.old_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.old_state)))?; + struct_ser.serialize_field("oldState", &v)?; + } + if self.new_state != 0 { + let v = UserState::try_from(self.new_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.new_state)))?; + struct_ser.serialize_field("newState", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_event::UserStateChanged { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "old_state", + "oldState", + "new_state", + "newState", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OldState, + NewState, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "oldState" | "old_state" => Ok(GeneratedField::OldState), + "newState" | "new_state" => Ok(GeneratedField::NewState), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_event::UserStateChanged; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionEvent.UserStateChanged") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut old_state__ = None; + let mut new_state__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::OldState => { + if old_state__.is_some() { + return Err(serde::de::Error::duplicate_field("oldState")); + } + old_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::NewState => { + if new_state__.is_some() { + return Err(serde::de::Error::duplicate_field("newState")); + } + new_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_event::UserStateChanged { + old_state: old_state__.unwrap_or_default(), + new_state: new_state__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionEvent.UserStateChanged", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentSessionMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.message.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage", len)?; + if let Some(v) = self.message.as_ref() { + match v { + agent_session_message::Message::AudioInput(v) => { + struct_ser.serialize_field("audioInput", v)?; + } + agent_session_message::Message::AudioOutput(v) => { + struct_ser.serialize_field("audioOutput", v)?; + } + agent_session_message::Message::Event(v) => { + struct_ser.serialize_field("event", v)?; + } + agent_session_message::Message::Request(v) => { + struct_ser.serialize_field("request", v)?; + } + agent_session_message::Message::Response(v) => { + struct_ser.serialize_field("response", v)?; + } + agent_session_message::Message::AudioPlaybackFlush(v) => { + struct_ser.serialize_field("audioPlaybackFlush", v)?; + } + agent_session_message::Message::AudioPlaybackClear(v) => { + struct_ser.serialize_field("audioPlaybackClear", v)?; + } + agent_session_message::Message::AudioPlaybackFinished(v) => { + struct_ser.serialize_field("audioPlaybackFinished", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentSessionMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio_input", + "audioInput", + "audio_output", + "audioOutput", + "event", + "request", + "response", + "audio_playback_flush", + "audioPlaybackFlush", + "audio_playback_clear", + "audioPlaybackClear", + "audio_playback_finished", + "audioPlaybackFinished", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AudioInput, + AudioOutput, + Event, + Request, + Response, + AudioPlaybackFlush, + AudioPlaybackClear, + AudioPlaybackFinished, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audioInput" | "audio_input" => Ok(GeneratedField::AudioInput), + "audioOutput" | "audio_output" => Ok(GeneratedField::AudioOutput), + "event" => Ok(GeneratedField::Event), + "request" => Ok(GeneratedField::Request), + "response" => Ok(GeneratedField::Response), + "audioPlaybackFlush" | "audio_playback_flush" => Ok(GeneratedField::AudioPlaybackFlush), + "audioPlaybackClear" | "audio_playback_clear" => Ok(GeneratedField::AudioPlaybackClear), + "audioPlaybackFinished" | "audio_playback_finished" => Ok(GeneratedField::AudioPlaybackFinished), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentSessionMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AudioInput => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("audioInput")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::AudioInput) +; + } + GeneratedField::AudioOutput => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("audioOutput")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::AudioOutput) +; + } + GeneratedField::Event => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("event")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::Event) +; + } + GeneratedField::Request => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("request")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::Request) +; + } + GeneratedField::Response => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("response")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::Response) +; + } + GeneratedField::AudioPlaybackFlush => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("audioPlaybackFlush")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::AudioPlaybackFlush) +; + } + GeneratedField::AudioPlaybackClear => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("audioPlaybackClear")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::AudioPlaybackClear) +; + } + GeneratedField::AudioPlaybackFinished => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("audioPlaybackFinished")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(agent_session_message::Message::AudioPlaybackFinished) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentSessionMessage { + message: message__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_message::ConsoleIo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_message::ConsoleIo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_message::ConsoleIo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage.ConsoleIO") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(agent_session_message::ConsoleIo { + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_message::console_io::AudioFrame { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.data.is_empty() { + len += 1; + } + if self.sample_rate != 0 { + len += 1; + } + if self.num_channels != 0 { + len += 1; + } + if self.samples_per_channel != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioFrame", len)?; + if !self.data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + } + if self.sample_rate != 0 { + struct_ser.serialize_field("sampleRate", &self.sample_rate)?; + } + if self.num_channels != 0 { + struct_ser.serialize_field("numChannels", &self.num_channels)?; + } + if self.samples_per_channel != 0 { + struct_ser.serialize_field("samplesPerChannel", &self.samples_per_channel)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_message::console_io::AudioFrame { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "data", + "sample_rate", + "sampleRate", + "num_channels", + "numChannels", + "samples_per_channel", + "samplesPerChannel", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Data, + SampleRate, + NumChannels, + SamplesPerChannel, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "data" => Ok(GeneratedField::Data), + "sampleRate" | "sample_rate" => Ok(GeneratedField::SampleRate), + "numChannels" | "num_channels" => Ok(GeneratedField::NumChannels), + "samplesPerChannel" | "samples_per_channel" => Ok(GeneratedField::SamplesPerChannel), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_message::console_io::AudioFrame; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage.ConsoleIO.AudioFrame") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut data__ = None; + let mut sample_rate__ = None; + let mut num_channels__ = None; + let mut samples_per_channel__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::SampleRate => { + if sample_rate__.is_some() { + return Err(serde::de::Error::duplicate_field("sampleRate")); + } + sample_rate__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::NumChannels => { + if num_channels__.is_some() { + return Err(serde::de::Error::duplicate_field("numChannels")); + } + num_channels__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::SamplesPerChannel => { + if samples_per_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("samplesPerChannel")); + } + samples_per_channel__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(agent_session_message::console_io::AudioFrame { + data: data__.unwrap_or_default(), + sample_rate: sample_rate__.unwrap_or_default(), + num_channels: num_channels__.unwrap_or_default(), + samples_per_channel: samples_per_channel__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioFrame", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_message::console_io::AudioPlaybackClear { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackClear", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_message::console_io::AudioPlaybackClear { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_message::console_io::AudioPlaybackClear; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackClear") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(agent_session_message::console_io::AudioPlaybackClear { + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackClear", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_message::console_io::AudioPlaybackFinished { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFinished", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_message::console_io::AudioPlaybackFinished { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_message::console_io::AudioPlaybackFinished; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFinished") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(agent_session_message::console_io::AudioPlaybackFinished { + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFinished", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for agent_session_message::console_io::AudioPlaybackFlush { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFlush", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for agent_session_message::console_io::AudioPlaybackFlush { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = agent_session_message::console_io::AudioPlaybackFlush; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFlush") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(agent_session_message::console_io::AudioPlaybackFlush { + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionMessage.ConsoleIO.AudioPlaybackFlush", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentSessionState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version != 0 { + len += 1; + } + if self.data.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionState", len)?; + if self.version != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?; + } + if let Some(v) = self.data.as_ref() { + match v { + agent_session_state::Data::Snapshot(v) => { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("snapshot", pbjson::private::base64::encode(&v).as_str())?; + } + agent_session_state::Data::Delta(v) => { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("delta", pbjson::private::base64::encode(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentSessionState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "version", + "snapshot", + "delta", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Version, + Snapshot, + Delta, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "version" => Ok(GeneratedField::Version), + "snapshot" => Ok(GeneratedField::Snapshot), + "delta" => Ok(GeneratedField::Delta), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentSessionState; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionState") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + let mut data__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Version => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("version")); + } + version__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Snapshot => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("snapshot")); + } + data__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| agent_session_state::Data::Snapshot(x.0)); + } + GeneratedField::Delta => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("delta")); + } + data__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| agent_session_state::Data::Delta(x.0)); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentSessionState { + version: version__.unwrap_or_default(), + data: data__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionState", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentSessionUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.model_usage.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.AgentSessionUsage", len)?; + if !self.model_usage.is_empty() { + struct_ser.serialize_field("modelUsage", &self.model_usage)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AgentSessionUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "model_usage", + "modelUsage", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ModelUsage, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "modelUsage" | "model_usage" => Ok(GeneratedField::ModelUsage), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentSessionUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.AgentSessionUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut model_usage__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ModelUsage => { + if model_usage__.is_some() { + return Err(serde::de::Error::duplicate_field("modelUsage")); + } + model_usage__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(AgentSessionUsage { + model_usage: model_usage__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.AgentSessionUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for AgentState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::AsInitializing => "AS_INITIALIZING", + Self::AsIdle => "AS_IDLE", + Self::AsListening => "AS_LISTENING", + Self::AsThinking => "AS_THINKING", + Self::AsSpeaking => "AS_SPEAKING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AgentState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "AS_INITIALIZING", + "AS_IDLE", + "AS_LISTENING", + "AS_THINKING", + "AS_SPEAKING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AgentState; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "AS_INITIALIZING" => Ok(AgentState::AsInitializing), + "AS_IDLE" => Ok(AgentState::AsIdle), + "AS_LISTENING" => Ok(AgentState::AsListening), + "AS_THINKING" => Ok(AgentState::AsThinking), + "AS_SPEAKING" => Ok(AgentState::AsSpeaking), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for AmdCategory { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::AmdUnknown => "AMD_UNKNOWN", + Self::AmdHuman => "AMD_HUMAN", + Self::AmdMachineIvr => "AMD_MACHINE_IVR", + Self::AmdMachineVm => "AMD_MACHINE_VM", + Self::AmdMachineUnavailable => "AMD_MACHINE_UNAVAILABLE", + Self::AmdUncertain => "AMD_UNCERTAIN", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AmdCategory { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "AMD_UNKNOWN", + "AMD_HUMAN", + "AMD_MACHINE_IVR", + "AMD_MACHINE_VM", + "AMD_MACHINE_UNAVAILABLE", + "AMD_UNCERTAIN", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AmdCategory; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "AMD_UNKNOWN" => Ok(AmdCategory::AmdUnknown), + "AMD_HUMAN" => Ok(AmdCategory::AmdHuman), + "AMD_MACHINE_IVR" => Ok(AmdCategory::AmdMachineIvr), + "AMD_MACHINE_VM" => Ok(AmdCategory::AmdMachineVm), + "AMD_MACHINE_UNAVAILABLE" => Ok(AmdCategory::AmdMachineUnavailable), + "AMD_UNCERTAIN" => Ok(AmdCategory::AmdUncertain), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for AudioEncoding { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::PcmS16le => "AUDIO_ENCODING_PCM_S16LE", + Self::Opus => "AUDIO_ENCODING_OPUS", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AudioEncoding { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "AUDIO_ENCODING_PCM_S16LE", + "AUDIO_ENCODING_OPUS", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AudioEncoding; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "AUDIO_ENCODING_PCM_S16LE" => Ok(AudioEncoding::PcmS16le), + "AUDIO_ENCODING_OPUS" => Ok(AudioEncoding::Opus), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for BufferStart { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.BufferStart", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BufferStart { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BufferStart; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.BufferStart") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(BufferStart { + }) + } + } + deserializer.deserialize_struct("livekit.agent.BufferStart", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BufferStop { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.BufferStop", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BufferStop { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BufferStop; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.BufferStop") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(BufferStop { + }) + } + } + deserializer.deserialize_struct("livekit.agent.BufferStop", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ChatContext { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.items.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ChatContext", len)?; + if !self.items.is_empty() { + struct_ser.serialize_field("items", &self.items)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ChatContext { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "items", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Items, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "items" => Ok(GeneratedField::Items), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ChatContext; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ChatContext") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut items__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Items => { + if items__.is_some() { + return Err(serde::de::Error::duplicate_field("items")); + } + items__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ChatContext { + items: items__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.ChatContext", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for chat_context::ChatItem { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.item.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ChatContext.ChatItem", len)?; + if let Some(v) = self.item.as_ref() { + match v { + chat_context::chat_item::Item::Message(v) => { + struct_ser.serialize_field("message", v)?; + } + chat_context::chat_item::Item::FunctionCall(v) => { + struct_ser.serialize_field("functionCall", v)?; + } + chat_context::chat_item::Item::FunctionCallOutput(v) => { + struct_ser.serialize_field("functionCallOutput", v)?; + } + chat_context::chat_item::Item::AgentHandoff(v) => { + struct_ser.serialize_field("agentHandoff", v)?; + } + chat_context::chat_item::Item::AgentConfigUpdate(v) => { + struct_ser.serialize_field("agentConfigUpdate", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for chat_context::ChatItem { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + "function_call", + "functionCall", + "function_call_output", + "functionCallOutput", + "agent_handoff", + "agentHandoff", + "agent_config_update", + "agentConfigUpdate", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + FunctionCall, + FunctionCallOutput, + AgentHandoff, + AgentConfigUpdate, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "message" => Ok(GeneratedField::Message), + "functionCall" | "function_call" => Ok(GeneratedField::FunctionCall), + "functionCallOutput" | "function_call_output" => Ok(GeneratedField::FunctionCallOutput), + "agentHandoff" | "agent_handoff" => Ok(GeneratedField::AgentHandoff), + "agentConfigUpdate" | "agent_config_update" => Ok(GeneratedField::AgentConfigUpdate), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = chat_context::ChatItem; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ChatContext.ChatItem") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut item__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + item__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_context::chat_item::Item::Message) +; + } + GeneratedField::FunctionCall => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCall")); + } + item__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_context::chat_item::Item::FunctionCall) +; + } + GeneratedField::FunctionCallOutput => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCallOutput")); + } + item__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_context::chat_item::Item::FunctionCallOutput) +; + } + GeneratedField::AgentHandoff => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("agentHandoff")); + } + item__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_context::chat_item::Item::AgentHandoff) +; + } + GeneratedField::AgentConfigUpdate => { + if item__.is_some() { + return Err(serde::de::Error::duplicate_field("agentConfigUpdate")); + } + item__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_context::chat_item::Item::AgentConfigUpdate) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(chat_context::ChatItem { + item: item__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ChatContext.ChatItem", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ChatMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.role != 0 { + len += 1; + } + if !self.content.is_empty() { + len += 1; + } + if self.interrupted { + len += 1; + } + if self.transcript_confidence.is_some() { + len += 1; + } + if !self.extra.is_empty() { + len += 1; + } + if self.metrics.is_some() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ChatMessage", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if self.role != 0 { + let v = ChatRole::try_from(self.role) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.role)))?; + struct_ser.serialize_field("role", &v)?; + } + if !self.content.is_empty() { + struct_ser.serialize_field("content", &self.content)?; + } + if self.interrupted { + struct_ser.serialize_field("interrupted", &self.interrupted)?; + } + if let Some(v) = self.transcript_confidence.as_ref() { + struct_ser.serialize_field("transcriptConfidence", v)?; + } + if !self.extra.is_empty() { + struct_ser.serialize_field("extra", &self.extra)?; + } + if let Some(v) = self.metrics.as_ref() { + struct_ser.serialize_field("metrics", v)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ChatMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "role", + "content", + "interrupted", + "transcript_confidence", + "transcriptConfidence", + "extra", + "metrics", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Role, + Content, + Interrupted, + TranscriptConfidence, + Extra, + Metrics, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "role" => Ok(GeneratedField::Role), + "content" => Ok(GeneratedField::Content), + "interrupted" => Ok(GeneratedField::Interrupted), + "transcriptConfidence" | "transcript_confidence" => Ok(GeneratedField::TranscriptConfidence), + "extra" => Ok(GeneratedField::Extra), + "metrics" => Ok(GeneratedField::Metrics), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ChatMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ChatMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut role__ = None; + let mut content__ = None; + let mut interrupted__ = None; + let mut transcript_confidence__ = None; + let mut extra__ = None; + let mut metrics__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Role => { + if role__.is_some() { + return Err(serde::de::Error::duplicate_field("role")); + } + role__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Content => { + if content__.is_some() { + return Err(serde::de::Error::duplicate_field("content")); + } + content__ = Some(map_.next_value()?); + } + GeneratedField::Interrupted => { + if interrupted__.is_some() { + return Err(serde::de::Error::duplicate_field("interrupted")); + } + interrupted__ = Some(map_.next_value()?); + } + GeneratedField::TranscriptConfidence => { + if transcript_confidence__.is_some() { + return Err(serde::de::Error::duplicate_field("transcriptConfidence")); + } + transcript_confidence__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Extra => { + if extra__.is_some() { + return Err(serde::de::Error::duplicate_field("extra")); + } + extra__ = Some( + map_.next_value::>()? + ); + } + GeneratedField::Metrics => { + if metrics__.is_some() { + return Err(serde::de::Error::duplicate_field("metrics")); + } + metrics__ = map_.next_value()?; + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ChatMessage { + id: id__.unwrap_or_default(), + role: role__.unwrap_or_default(), + content: content__.unwrap_or_default(), + interrupted: interrupted__.unwrap_or_default(), + transcript_confidence: transcript_confidence__, + extra: extra__.unwrap_or_default(), + metrics: metrics__, + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ChatMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for chat_message::ChatContent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.payload.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ChatMessage.ChatContent", len)?; + if let Some(v) = self.payload.as_ref() { + match v { + chat_message::chat_content::Payload::Text(v) => { + struct_ser.serialize_field("text", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for chat_message::ChatContent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "text", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Text, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "text" => Ok(GeneratedField::Text), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = chat_message::ChatContent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ChatMessage.ChatContent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Text => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + payload__ = map_.next_value::<::std::option::Option<_>>()?.map(chat_message::chat_content::Payload::Text); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(chat_message::ChatContent { + payload: payload__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ChatMessage.ChatContent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ChatRole { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Developer => "DEVELOPER", + Self::System => "SYSTEM", + Self::User => "USER", + Self::Assistant => "ASSISTANT", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ChatRole { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "DEVELOPER", + "SYSTEM", + "USER", + "ASSISTANT", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ChatRole; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "DEVELOPER" => Ok(ChatRole::Developer), + "SYSTEM" => Ok(ChatRole::System), + "USER" => Ok(ChatRole::User), + "ASSISTANT" => Ok(ChatRole::Assistant), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ClientMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_at.is_some() { + len += 1; + } + if self.message.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ClientMessage", len)?; + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + if let Some(v) = self.message.as_ref() { + match v { + client_message::Message::SessionCreate(v) => { + struct_ser.serialize_field("sessionCreate", v)?; + } + client_message::Message::InputAudio(v) => { + struct_ser.serialize_field("inputAudio", v)?; + } + client_message::Message::SessionFlush(v) => { + struct_ser.serialize_field("sessionFlush", v)?; + } + client_message::Message::SessionClose(v) => { + struct_ser.serialize_field("sessionClose", v)?; + } + client_message::Message::InferenceStart(v) => { + struct_ser.serialize_field("inferenceStart", v)?; + } + client_message::Message::InferenceStop(v) => { + struct_ser.serialize_field("inferenceStop", v)?; + } + client_message::Message::BufferStart(v) => { + struct_ser.serialize_field("bufferStart", v)?; + } + client_message::Message::BufferStop(v) => { + struct_ser.serialize_field("bufferStop", v)?; + } + client_message::Message::EotInputChatContext(v) => { + struct_ser.serialize_field("eotInputChatContext", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ClientMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_at", + "createdAt", + "session_create", + "sessionCreate", + "input_audio", + "inputAudio", + "session_flush", + "sessionFlush", + "session_close", + "sessionClose", + "inference_start", + "inferenceStart", + "inference_stop", + "inferenceStop", + "buffer_start", + "bufferStart", + "buffer_stop", + "bufferStop", + "eot_input_chat_context", + "eotInputChatContext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedAt, + SessionCreate, + InputAudio, + SessionFlush, + SessionClose, + InferenceStart, + InferenceStop, + BufferStart, + BufferStop, + EotInputChatContext, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + "sessionCreate" | "session_create" => Ok(GeneratedField::SessionCreate), + "inputAudio" | "input_audio" => Ok(GeneratedField::InputAudio), + "sessionFlush" | "session_flush" => Ok(GeneratedField::SessionFlush), + "sessionClose" | "session_close" => Ok(GeneratedField::SessionClose), + "inferenceStart" | "inference_start" => Ok(GeneratedField::InferenceStart), + "inferenceStop" | "inference_stop" => Ok(GeneratedField::InferenceStop), + "bufferStart" | "buffer_start" => Ok(GeneratedField::BufferStart), + "bufferStop" | "buffer_stop" => Ok(GeneratedField::BufferStop), + "eotInputChatContext" | "eot_input_chat_context" => Ok(GeneratedField::EotInputChatContext), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ClientMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ClientMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_at__ = None; + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::SessionCreate => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionCreate")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::SessionCreate) +; + } + GeneratedField::InputAudio => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("inputAudio")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::InputAudio) +; + } + GeneratedField::SessionFlush => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionFlush")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::SessionFlush) +; + } + GeneratedField::SessionClose => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionClose")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::SessionClose) +; + } + GeneratedField::InferenceStart => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStart")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::InferenceStart) +; + } + GeneratedField::InferenceStop => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStop")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::InferenceStop) +; + } + GeneratedField::BufferStart => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("bufferStart")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::BufferStart) +; + } + GeneratedField::BufferStop => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("bufferStop")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::BufferStop) +; + } + GeneratedField::EotInputChatContext => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("eotInputChatContext")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(client_message::Message::EotInputChatContext) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ClientMessage { + created_at: created_at__, + message: message__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ClientMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DebugMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.payload.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.DebugMessage", len)?; + if let Some(v) = self.payload.as_ref() { + struct_ser.serialize_field("payload", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DebugMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "payload", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Payload, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "payload" => Ok(GeneratedField::Payload), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DebugMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.DebugMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DebugMessage { + payload: payload__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.DebugMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EotInferenceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.audio.is_empty() { + len += 1; + } + if !self.assistant_text.is_empty() { + len += 1; + } + if self.encoding != 0 { + len += 1; + } + if self.sample_rate != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotInferenceRequest", len)?; + if !self.audio.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("audio", pbjson::private::base64::encode(&self.audio).as_str())?; + } + if !self.assistant_text.is_empty() { + struct_ser.serialize_field("assistantText", &self.assistant_text)?; + } + if self.encoding != 0 { + let v = AudioEncoding::try_from(self.encoding) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encoding)))?; + struct_ser.serialize_field("encoding", &v)?; + } + if self.sample_rate != 0 { + struct_ser.serialize_field("sampleRate", &self.sample_rate)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotInferenceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio", + "assistant_text", + "assistantText", + "encoding", + "sample_rate", + "sampleRate", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Audio, + AssistantText, + Encoding, + SampleRate, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audio" => Ok(GeneratedField::Audio), + "assistantText" | "assistant_text" => Ok(GeneratedField::AssistantText), + "encoding" => Ok(GeneratedField::Encoding), + "sampleRate" | "sample_rate" => Ok(GeneratedField::SampleRate), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotInferenceRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotInferenceRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut audio__ = None; + let mut assistant_text__ = None; + let mut encoding__ = None; + let mut sample_rate__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Audio => { + if audio__.is_some() { + return Err(serde::de::Error::duplicate_field("audio")); + } + audio__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::AssistantText => { + if assistant_text__.is_some() { + return Err(serde::de::Error::duplicate_field("assistantText")); + } + assistant_text__ = Some(map_.next_value()?); + } + GeneratedField::Encoding => { + if encoding__.is_some() { + return Err(serde::de::Error::duplicate_field("encoding")); + } + encoding__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SampleRate => { + if sample_rate__.is_some() { + return Err(serde::de::Error::duplicate_field("sampleRate")); + } + sample_rate__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotInferenceRequest { + audio: audio__.unwrap_or_default(), + assistant_text: assistant_text__.unwrap_or_default(), + encoding: encoding__.unwrap_or_default(), + sample_rate: sample_rate__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotInferenceRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EotInferenceResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.probability != 0. { + len += 1; + } + if self.stats.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotInferenceResponse", len)?; + if self.probability != 0. { + struct_ser.serialize_field("probability", &self.probability)?; + } + if let Some(v) = self.stats.as_ref() { + struct_ser.serialize_field("stats", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotInferenceResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "probability", + "stats", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Probability, + Stats, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "probability" => Ok(GeneratedField::Probability), + "stats" => Ok(GeneratedField::Stats), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotInferenceResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotInferenceResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut probability__ = None; + let mut stats__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Probability => { + if probability__.is_some() { + return Err(serde::de::Error::duplicate_field("probability")); + } + probability__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Stats => { + if stats__.is_some() { + return Err(serde::de::Error::duplicate_field("stats")); + } + stats__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotInferenceResponse { + probability: probability__.unwrap_or_default(), + stats: stats__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotInferenceResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EotInputChatContext { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.messages.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotInputChatContext", len)?; + if !self.messages.is_empty() { + struct_ser.serialize_field("messages", &self.messages)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotInputChatContext { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "messages", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Messages, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "messages" => Ok(GeneratedField::Messages), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotInputChatContext; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotInputChatContext") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut messages__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Messages => { + if messages__.is_some() { + return Err(serde::de::Error::duplicate_field("messages")); + } + messages__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotInputChatContext { + messages: messages__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotInputChatContext", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EotModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.provider.is_empty() { + len += 1; + } + if !self.model.is_empty() { + len += 1; + } + if self.total_requests != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotModelUsage", len)?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; + } + if !self.model.is_empty() { + struct_ser.serialize_field("model", &self.model)?; + } + if self.total_requests != 0 { + struct_ser.serialize_field("totalRequests", &self.total_requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provider", + "model", + "total_requests", + "totalRequests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Provider, + Model, + TotalRequests, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provider" => Ok(GeneratedField::Provider), + "model" => Ok(GeneratedField::Model), + "totalRequests" | "total_requests" => Ok(GeneratedField::TotalRequests), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provider__ = None; + let mut model__ = None; + let mut total_requests__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); + } + GeneratedField::Model => { + if model__.is_some() { + return Err(serde::de::Error::duplicate_field("model")); + } + model__ = Some(map_.next_value()?); + } + GeneratedField::TotalRequests => { + if total_requests__.is_some() { + return Err(serde::de::Error::duplicate_field("totalRequests")); + } + total_requests__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotModelUsage { + provider: provider__.unwrap_or_default(), + model: model__.unwrap_or_default(), + total_requests: total_requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EotPrediction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.probability != 0. { + len += 1; + } + if self.inference_stats.is_some() { + len += 1; + } + if self.backend != 0 { + len += 1; + } + if self.backchannel_probability != 0. { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotPrediction", len)?; + if self.probability != 0. { + struct_ser.serialize_field("probability", &self.probability)?; + } + if let Some(v) = self.inference_stats.as_ref() { + struct_ser.serialize_field("inferenceStats", v)?; + } + if self.backend != 0 { + let v = eot_prediction::EotBackend::try_from(self.backend) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backend)))?; + struct_ser.serialize_field("backend", &v)?; + } + if self.backchannel_probability != 0. { + struct_ser.serialize_field("backchannelProbability", &self.backchannel_probability)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotPrediction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "probability", + "inference_stats", + "inferenceStats", + "backend", + "backchannel_probability", + "backchannelProbability", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Probability, + InferenceStats, + Backend, + BackchannelProbability, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "probability" => Ok(GeneratedField::Probability), + "inferenceStats" | "inference_stats" => Ok(GeneratedField::InferenceStats), + "backend" => Ok(GeneratedField::Backend), + "backchannelProbability" | "backchannel_probability" => Ok(GeneratedField::BackchannelProbability), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotPrediction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotPrediction") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut probability__ = None; + let mut inference_stats__ = None; + let mut backend__ = None; + let mut backchannel_probability__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Probability => { + if probability__.is_some() { + return Err(serde::de::Error::duplicate_field("probability")); + } + probability__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InferenceStats => { + if inference_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStats")); + } + inference_stats__ = map_.next_value()?; + } + GeneratedField::Backend => { + if backend__.is_some() { + return Err(serde::de::Error::duplicate_field("backend")); + } + backend__ = Some(map_.next_value::()? as i32); + } + GeneratedField::BackchannelProbability => { + if backchannel_probability__.is_some() { + return Err(serde::de::Error::duplicate_field("backchannelProbability")); + } + backchannel_probability__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotPrediction { + probability: probability__.unwrap_or_default(), + inference_stats: inference_stats__, + backend: backend__.unwrap_or_default(), + backchannel_probability: backchannel_probability__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotPrediction", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for eot_prediction::EotBackend { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "EOT_BACKEND_UNKNOWN", + Self::Multimodal => "EOT_BACKEND_MULTIMODAL", + Self::Text => "EOT_BACKEND_TEXT", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for eot_prediction::EotBackend { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "EOT_BACKEND_UNKNOWN", + "EOT_BACKEND_MULTIMODAL", + "EOT_BACKEND_TEXT", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = eot_prediction::EotBackend; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "EOT_BACKEND_UNKNOWN" => Ok(eot_prediction::EotBackend::Unknown), + "EOT_BACKEND_MULTIMODAL" => Ok(eot_prediction::EotBackend::Multimodal), + "EOT_BACKEND_TEXT" => Ok(eot_prediction::EotBackend::Text), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for EotSettings { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.detection_interval.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.EotSettings", len)?; + if let Some(v) = self.detection_interval.as_ref() { + struct_ser.serialize_field("detectionInterval", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EotSettings { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "detection_interval", + "detectionInterval", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + DetectionInterval, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "detectionInterval" | "detection_interval" => Ok(GeneratedField::DetectionInterval), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EotSettings; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.EotSettings") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut detection_interval__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::DetectionInterval => { + if detection_interval__.is_some() { + return Err(serde::de::Error::duplicate_field("detectionInterval")); + } + detection_interval__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(EotSettings { + detection_interval: detection_interval__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.EotSettings", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for FunctionCall { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.call_id.is_empty() { + len += 1; + } + if !self.arguments.is_empty() { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.FunctionCall", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.call_id.is_empty() { + struct_ser.serialize_field("callId", &self.call_id)?; + } + if !self.arguments.is_empty() { + struct_ser.serialize_field("arguments", &self.arguments)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FunctionCall { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "call_id", + "callId", + "arguments", + "name", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + CallId, + Arguments, + Name, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "callId" | "call_id" => Ok(GeneratedField::CallId), + "arguments" => Ok(GeneratedField::Arguments), + "name" => Ok(GeneratedField::Name), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FunctionCall; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.FunctionCall") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut call_id__ = None; + let mut arguments__ = None; + let mut name__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::CallId => { + if call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("callId")); + } + call_id__ = Some(map_.next_value()?); + } + GeneratedField::Arguments => { + if arguments__.is_some() { + return Err(serde::de::Error::duplicate_field("arguments")); + } + arguments__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(FunctionCall { + id: id__.unwrap_or_default(), + call_id: call_id__.unwrap_or_default(), + arguments: arguments__.unwrap_or_default(), + name: name__.unwrap_or_default(), + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.FunctionCall", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for FunctionCallOutput { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + if !self.call_id.is_empty() { + len += 1; + } + if !self.output.is_empty() { + len += 1; + } + if self.is_error { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.FunctionCallOutput", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.call_id.is_empty() { + struct_ser.serialize_field("callId", &self.call_id)?; + } + if !self.output.is_empty() { + struct_ser.serialize_field("output", &self.output)?; + } + if self.is_error { + struct_ser.serialize_field("isError", &self.is_error)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FunctionCallOutput { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "name", + "call_id", + "callId", + "output", + "is_error", + "isError", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Name, + CallId, + Output, + IsError, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "name" => Ok(GeneratedField::Name), + "callId" | "call_id" => Ok(GeneratedField::CallId), + "output" => Ok(GeneratedField::Output), + "isError" | "is_error" => Ok(GeneratedField::IsError), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FunctionCallOutput; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.FunctionCallOutput") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut name__ = None; + let mut call_id__ = None; + let mut output__ = None; + let mut is_error__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::CallId => { + if call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("callId")); + } + call_id__ = Some(map_.next_value()?); + } + GeneratedField::Output => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("output")); + } + output__ = Some(map_.next_value()?); + } + GeneratedField::IsError => { + if is_error__.is_some() { + return Err(serde::de::Error::duplicate_field("isError")); + } + is_error__ = Some(map_.next_value()?); + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(FunctionCallOutput { + id: id__.unwrap_or_default(), + name: name__.unwrap_or_default(), + call_id: call_id__.unwrap_or_default(), + output: output__.unwrap_or_default(), + is_error: is_error__.unwrap_or_default(), + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.FunctionCallOutput", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetRunningAgentJobsRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.GetRunningAgentJobsRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetRunningAgentJobsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GetRunningAgentJobsRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.GetRunningAgentJobsRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(GetRunningAgentJobsRequest { + }) + } + } + deserializer.deserialize_struct("livekit.agent.GetRunningAgentJobsRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetRunningAgentJobsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.jobs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.GetRunningAgentJobsResponse", len)?; + if !self.jobs.is_empty() { + struct_ser.serialize_field("jobs", &self.jobs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetRunningAgentJobsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "jobs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Jobs, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "jobs" => Ok(GeneratedField::Jobs), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GetRunningAgentJobsResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.GetRunningAgentJobsResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut jobs__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Jobs => { + if jobs__.is_some() { + return Err(serde::de::Error::duplicate_field("jobs")); + } + jobs__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(GetRunningAgentJobsResponse { + jobs: jobs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.GetRunningAgentJobsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceError { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + if self.code != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceError", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + if self.code != 0 { + struct_ser.serialize_field("code", &self.code)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceError { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + "code", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + Code, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "message" => Ok(GeneratedField::Message), + "code" => Ok(GeneratedField::Code), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceError; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceError") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + let mut code__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + GeneratedField::Code => { + if code__.is_some() { + return Err(serde::de::Error::duplicate_field("code")); + } + code__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceError { + message: message__.unwrap_or_default(), + code: code__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceError", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.request.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceRequest", len)?; + if let Some(v) = self.request.as_ref() { + match v { + inference_request::Request::EotInferenceRequest(v) => { + struct_ser.serialize_field("eotInferenceRequest", v)?; + } + inference_request::Request::InterruptionInferenceRequest(v) => { + struct_ser.serialize_field("interruptionInferenceRequest", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "eot_inference_request", + "eotInferenceRequest", + "interruption_inference_request", + "interruptionInferenceRequest", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EotInferenceRequest, + InterruptionInferenceRequest, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "eotInferenceRequest" | "eot_inference_request" => Ok(GeneratedField::EotInferenceRequest), + "interruptionInferenceRequest" | "interruption_inference_request" => Ok(GeneratedField::InterruptionInferenceRequest), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut request__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::EotInferenceRequest => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("eotInferenceRequest")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(inference_request::Request::EotInferenceRequest) +; + } + GeneratedField::InterruptionInferenceRequest => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("interruptionInferenceRequest")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(inference_request::Request::InterruptionInferenceRequest) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceRequest { + request: request__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.response.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceResponse", len)?; + if let Some(v) = self.response.as_ref() { + match v { + inference_response::Response::EotInferenceResponse(v) => { + struct_ser.serialize_field("eotInferenceResponse", v)?; + } + inference_response::Response::InterruptionInferenceResponse(v) => { + struct_ser.serialize_field("interruptionInferenceResponse", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "eot_inference_response", + "eotInferenceResponse", + "interruption_inference_response", + "interruptionInferenceResponse", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EotInferenceResponse, + InterruptionInferenceResponse, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "eotInferenceResponse" | "eot_inference_response" => Ok(GeneratedField::EotInferenceResponse), + "interruptionInferenceResponse" | "interruption_inference_response" => Ok(GeneratedField::InterruptionInferenceResponse), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut response__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::EotInferenceResponse => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("eotInferenceResponse")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(inference_response::Response::EotInferenceResponse) +; + } + GeneratedField::InterruptionInferenceResponse => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("interruptionInferenceResponse")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(inference_response::Response::InterruptionInferenceResponse) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceResponse { + response: response__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceStart { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.request_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceStart", len)?; + if !self.request_id.is_empty() { + struct_ser.serialize_field("requestId", &self.request_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceStart { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "request_id", + "requestId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + RequestId, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requestId" | "request_id" => Ok(GeneratedField::RequestId), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceStart; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceStart") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut request_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::RequestId => { + if request_id__.is_some() { + return Err(serde::de::Error::duplicate_field("requestId")); + } + request_id__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceStart { + request_id: request_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceStart", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceStarted { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.InferenceStarted", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceStarted { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceStarted; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceStarted") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(InferenceStarted { + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceStarted", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceStats { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.earliest_client_created_at.is_some() { + len += 1; + } + if self.latest_client_created_at.is_some() { + len += 1; + } + if self.client_e2e_latency.is_some() { + len += 1; + } + if self.server_e2e_latency.is_some() { + len += 1; + } + if self.preprocessing_duration.is_some() { + len += 1; + } + if self.inference_duration.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceStats", len)?; + if let Some(v) = self.earliest_client_created_at.as_ref() { + struct_ser.serialize_field("earliestClientCreatedAt", v)?; + } + if let Some(v) = self.latest_client_created_at.as_ref() { + struct_ser.serialize_field("latestClientCreatedAt", v)?; + } + if let Some(v) = self.client_e2e_latency.as_ref() { + struct_ser.serialize_field("clientE2eLatency", v)?; + } + if let Some(v) = self.server_e2e_latency.as_ref() { + struct_ser.serialize_field("serverE2eLatency", v)?; + } + if let Some(v) = self.preprocessing_duration.as_ref() { + struct_ser.serialize_field("preprocessingDuration", v)?; + } + if let Some(v) = self.inference_duration.as_ref() { + struct_ser.serialize_field("inferenceDuration", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceStats { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "earliest_client_created_at", + "earliestClientCreatedAt", + "latest_client_created_at", + "latestClientCreatedAt", + "client_e2e_latency", + "clientE2eLatency", + "server_e2e_latency", + "serverE2eLatency", + "preprocessing_duration", + "preprocessingDuration", + "inference_duration", + "inferenceDuration", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EarliestClientCreatedAt, + LatestClientCreatedAt, + ClientE2eLatency, + ServerE2eLatency, + PreprocessingDuration, + InferenceDuration, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "earliestClientCreatedAt" | "earliest_client_created_at" => Ok(GeneratedField::EarliestClientCreatedAt), + "latestClientCreatedAt" | "latest_client_created_at" => Ok(GeneratedField::LatestClientCreatedAt), + "clientE2eLatency" | "client_e2e_latency" => Ok(GeneratedField::ClientE2eLatency), + "serverE2eLatency" | "server_e2e_latency" => Ok(GeneratedField::ServerE2eLatency), + "preprocessingDuration" | "preprocessing_duration" => Ok(GeneratedField::PreprocessingDuration), + "inferenceDuration" | "inference_duration" => Ok(GeneratedField::InferenceDuration), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceStats; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceStats") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut earliest_client_created_at__ = None; + let mut latest_client_created_at__ = None; + let mut client_e2e_latency__ = None; + let mut server_e2e_latency__ = None; + let mut preprocessing_duration__ = None; + let mut inference_duration__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::EarliestClientCreatedAt => { + if earliest_client_created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("earliestClientCreatedAt")); + } + earliest_client_created_at__ = map_.next_value()?; + } + GeneratedField::LatestClientCreatedAt => { + if latest_client_created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("latestClientCreatedAt")); + } + latest_client_created_at__ = map_.next_value()?; + } + GeneratedField::ClientE2eLatency => { + if client_e2e_latency__.is_some() { + return Err(serde::de::Error::duplicate_field("clientE2eLatency")); + } + client_e2e_latency__ = map_.next_value()?; + } + GeneratedField::ServerE2eLatency => { + if server_e2e_latency__.is_some() { + return Err(serde::de::Error::duplicate_field("serverE2eLatency")); + } + server_e2e_latency__ = map_.next_value()?; + } + GeneratedField::PreprocessingDuration => { + if preprocessing_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("preprocessingDuration")); + } + preprocessing_duration__ = map_.next_value()?; + } + GeneratedField::InferenceDuration => { + if inference_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceDuration")); + } + inference_duration__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceStats { + earliest_client_created_at: earliest_client_created_at__, + latest_client_created_at: latest_client_created_at__, + client_e2e_latency: client_e2e_latency__, + server_e2e_latency: server_e2e_latency__, + preprocessing_duration: preprocessing_duration__, + inference_duration: inference_duration__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceStats", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceStop { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.request_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InferenceStop", len)?; + if !self.request_id.is_empty() { + struct_ser.serialize_field("requestId", &self.request_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceStop { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "request_id", + "requestId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + RequestId, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requestId" | "request_id" => Ok(GeneratedField::RequestId), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceStop; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceStop") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut request_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::RequestId => { + if request_id__.is_some() { + return Err(serde::de::Error::duplicate_field("requestId")); + } + request_id__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InferenceStop { + request_id: request_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceStop", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InferenceStopped { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.InferenceStopped", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InferenceStopped { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InferenceStopped; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InferenceStopped") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(InferenceStopped { + }) + } + } + deserializer.deserialize_struct("livekit.agent.InferenceStopped", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InputAudio { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.audio.is_empty() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + if self.num_samples != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InputAudio", len)?; + if !self.audio.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("audio", pbjson::private::base64::encode(&self.audio).as_str())?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + if self.num_samples != 0 { + struct_ser.serialize_field("numSamples", &self.num_samples)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InputAudio { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio", + "created_at", + "createdAt", + "num_samples", + "numSamples", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Audio, + CreatedAt, + NumSamples, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audio" => Ok(GeneratedField::Audio), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + "numSamples" | "num_samples" => Ok(GeneratedField::NumSamples), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InputAudio; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InputAudio") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut audio__ = None; + let mut created_at__ = None; + let mut num_samples__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Audio => { + if audio__.is_some() { + return Err(serde::de::Error::duplicate_field("audio")); + } + audio__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::NumSamples => { + if num_samples__.is_some() { + return Err(serde::de::Error::duplicate_field("numSamples")); + } + num_samples__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InputAudio { + audio: audio__.unwrap_or_default(), + created_at: created_at__, + num_samples: num_samples__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InputAudio", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InterruptionInferenceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.audio.is_empty() { + len += 1; + } + if self.encoding != 0 { + len += 1; + } + if self.sample_rate != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InterruptionInferenceRequest", len)?; + if !self.audio.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("audio", pbjson::private::base64::encode(&self.audio).as_str())?; + } + if self.encoding != 0 { + let v = AudioEncoding::try_from(self.encoding) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encoding)))?; + struct_ser.serialize_field("encoding", &v)?; + } + if self.sample_rate != 0 { + struct_ser.serialize_field("sampleRate", &self.sample_rate)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InterruptionInferenceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio", + "encoding", + "sample_rate", + "sampleRate", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Audio, + Encoding, + SampleRate, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audio" => Ok(GeneratedField::Audio), + "encoding" => Ok(GeneratedField::Encoding), + "sampleRate" | "sample_rate" => Ok(GeneratedField::SampleRate), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InterruptionInferenceRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InterruptionInferenceRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut audio__ = None; + let mut encoding__ = None; + let mut sample_rate__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Audio => { + if audio__.is_some() { + return Err(serde::de::Error::duplicate_field("audio")); + } + audio__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Encoding => { + if encoding__.is_some() { + return Err(serde::de::Error::duplicate_field("encoding")); + } + encoding__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SampleRate => { + if sample_rate__.is_some() { + return Err(serde::de::Error::duplicate_field("sampleRate")); + } + sample_rate__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InterruptionInferenceRequest { + audio: audio__.unwrap_or_default(), + encoding: encoding__.unwrap_or_default(), + sample_rate: sample_rate__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InterruptionInferenceRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InterruptionInferenceResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.is_interruption { + len += 1; + } + if !self.probabilities.is_empty() { + len += 1; + } + if self.stats.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InterruptionInferenceResponse", len)?; + if self.is_interruption { + struct_ser.serialize_field("isInterruption", &self.is_interruption)?; + } + if !self.probabilities.is_empty() { + struct_ser.serialize_field("probabilities", &self.probabilities)?; + } + if let Some(v) = self.stats.as_ref() { + struct_ser.serialize_field("stats", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InterruptionInferenceResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "is_interruption", + "isInterruption", + "probabilities", + "stats", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IsInterruption, + Probabilities, + Stats, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "isInterruption" | "is_interruption" => Ok(GeneratedField::IsInterruption), + "probabilities" => Ok(GeneratedField::Probabilities), + "stats" => Ok(GeneratedField::Stats), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InterruptionInferenceResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InterruptionInferenceResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut is_interruption__ = None; + let mut probabilities__ = None; + let mut stats__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::IsInterruption => { + if is_interruption__.is_some() { + return Err(serde::de::Error::duplicate_field("isInterruption")); + } + is_interruption__ = Some(map_.next_value()?); + } + GeneratedField::Probabilities => { + if probabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("probabilities")); + } + probabilities__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::Stats => { + if stats__.is_some() { + return Err(serde::de::Error::duplicate_field("stats")); + } + stats__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InterruptionInferenceResponse { + is_interruption: is_interruption__.unwrap_or_default(), + probabilities: probabilities__.unwrap_or_default(), + stats: stats__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InterruptionInferenceResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InterruptionModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.provider.is_empty() { + len += 1; + } + if !self.model.is_empty() { + len += 1; + } + if self.total_requests != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InterruptionModelUsage", len)?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; + } + if !self.model.is_empty() { + struct_ser.serialize_field("model", &self.model)?; + } + if self.total_requests != 0 { + struct_ser.serialize_field("totalRequests", &self.total_requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InterruptionModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provider", + "model", + "total_requests", + "totalRequests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Provider, + Model, + TotalRequests, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provider" => Ok(GeneratedField::Provider), + "model" => Ok(GeneratedField::Model), + "totalRequests" | "total_requests" => Ok(GeneratedField::TotalRequests), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InterruptionModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InterruptionModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provider__ = None; + let mut model__ = None; + let mut total_requests__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); + } + GeneratedField::Model => { + if model__.is_some() { + return Err(serde::de::Error::duplicate_field("model")); + } + model__ = Some(map_.next_value()?); + } + GeneratedField::TotalRequests => { + if total_requests__.is_some() { + return Err(serde::de::Error::duplicate_field("totalRequests")); + } + total_requests__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InterruptionModelUsage { + provider: provider__.unwrap_or_default(), + model: model__.unwrap_or_default(), + total_requests: total_requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.InterruptionModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InterruptionPrediction { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.is_interruption { + len += 1; + } + if !self.probabilities.is_empty() { + len += 1; + } + if self.inference_stats.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InterruptionPrediction", len)?; + if self.is_interruption { + struct_ser.serialize_field("isInterruption", &self.is_interruption)?; + } + if !self.probabilities.is_empty() { + struct_ser.serialize_field("probabilities", &self.probabilities)?; + } + if let Some(v) = self.inference_stats.as_ref() { + struct_ser.serialize_field("inferenceStats", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InterruptionPrediction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "is_interruption", + "isInterruption", + "probabilities", + "inference_stats", + "inferenceStats", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IsInterruption, + Probabilities, + InferenceStats, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "isInterruption" | "is_interruption" => Ok(GeneratedField::IsInterruption), + "probabilities" => Ok(GeneratedField::Probabilities), + "inferenceStats" | "inference_stats" => Ok(GeneratedField::InferenceStats), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InterruptionPrediction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InterruptionPrediction") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut is_interruption__ = None; + let mut probabilities__ = None; + let mut inference_stats__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::IsInterruption => { + if is_interruption__.is_some() { + return Err(serde::de::Error::duplicate_field("isInterruption")); + } + is_interruption__ = Some(map_.next_value()?); + } + GeneratedField::Probabilities => { + if probabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("probabilities")); + } + probabilities__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::InferenceStats => { + if inference_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStats")); + } + inference_stats__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InterruptionPrediction { + is_interruption: is_interruption__.unwrap_or_default(), + probabilities: probabilities__.unwrap_or_default(), + inference_stats: inference_stats__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InterruptionPrediction", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InterruptionSettings { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.threshold != 0. { + len += 1; + } + if self.min_frames != 0 { + len += 1; + } + if self.max_audio_duration.is_some() { + len += 1; + } + if self.audio_prefix_duration.is_some() { + len += 1; + } + if self.detection_interval.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.InterruptionSettings", len)?; + if self.threshold != 0. { + struct_ser.serialize_field("threshold", &self.threshold)?; + } + if self.min_frames != 0 { + struct_ser.serialize_field("minFrames", &self.min_frames)?; + } + if let Some(v) = self.max_audio_duration.as_ref() { + struct_ser.serialize_field("maxAudioDuration", v)?; + } + if let Some(v) = self.audio_prefix_duration.as_ref() { + struct_ser.serialize_field("audioPrefixDuration", v)?; + } + if let Some(v) = self.detection_interval.as_ref() { + struct_ser.serialize_field("detectionInterval", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InterruptionSettings { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "threshold", + "min_frames", + "minFrames", + "max_audio_duration", + "maxAudioDuration", + "audio_prefix_duration", + "audioPrefixDuration", + "detection_interval", + "detectionInterval", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Threshold, + MinFrames, + MaxAudioDuration, + AudioPrefixDuration, + DetectionInterval, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "threshold" => Ok(GeneratedField::Threshold), + "minFrames" | "min_frames" => Ok(GeneratedField::MinFrames), + "maxAudioDuration" | "max_audio_duration" => Ok(GeneratedField::MaxAudioDuration), + "audioPrefixDuration" | "audio_prefix_duration" => Ok(GeneratedField::AudioPrefixDuration), + "detectionInterval" | "detection_interval" => Ok(GeneratedField::DetectionInterval), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InterruptionSettings; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.InterruptionSettings") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut threshold__ = None; + let mut min_frames__ = None; + let mut max_audio_duration__ = None; + let mut audio_prefix_duration__ = None; + let mut detection_interval__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Threshold => { + if threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("threshold")); + } + threshold__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::MinFrames => { + if min_frames__.is_some() { + return Err(serde::de::Error::duplicate_field("minFrames")); + } + min_frames__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::MaxAudioDuration => { + if max_audio_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("maxAudioDuration")); + } + max_audio_duration__ = map_.next_value()?; + } + GeneratedField::AudioPrefixDuration => { + if audio_prefix_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("audioPrefixDuration")); + } + audio_prefix_duration__ = map_.next_value()?; + } + GeneratedField::DetectionInterval => { + if detection_interval__.is_some() { + return Err(serde::de::Error::duplicate_field("detectionInterval")); + } + detection_interval__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(InterruptionSettings { + threshold: threshold__.unwrap_or_default(), + min_frames: min_frames__.unwrap_or_default(), + max_audio_duration: max_audio_duration__, + audio_prefix_duration: audio_prefix_duration__, + detection_interval: detection_interval__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.InterruptionSettings", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LlmModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.provider.is_empty() { + len += 1; + } + if !self.model.is_empty() { + len += 1; + } + if self.input_tokens != 0 { + len += 1; + } + if self.input_cached_tokens != 0 { + len += 1; + } + if self.input_audio_tokens != 0 { + len += 1; + } + if self.input_cached_audio_tokens != 0 { + len += 1; + } + if self.input_text_tokens != 0 { + len += 1; + } + if self.input_cached_text_tokens != 0 { + len += 1; + } + if self.input_image_tokens != 0 { + len += 1; + } + if self.input_cached_image_tokens != 0 { + len += 1; + } + if self.output_tokens != 0 { + len += 1; + } + if self.output_audio_tokens != 0 { + len += 1; + } + if self.output_text_tokens != 0 { + len += 1; + } + if self.session_duration != 0. { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.LLMModelUsage", len)?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; + } + if !self.model.is_empty() { + struct_ser.serialize_field("model", &self.model)?; + } + if self.input_tokens != 0 { + struct_ser.serialize_field("inputTokens", &self.input_tokens)?; + } + if self.input_cached_tokens != 0 { + struct_ser.serialize_field("inputCachedTokens", &self.input_cached_tokens)?; + } + if self.input_audio_tokens != 0 { + struct_ser.serialize_field("inputAudioTokens", &self.input_audio_tokens)?; + } + if self.input_cached_audio_tokens != 0 { + struct_ser.serialize_field("inputCachedAudioTokens", &self.input_cached_audio_tokens)?; + } + if self.input_text_tokens != 0 { + struct_ser.serialize_field("inputTextTokens", &self.input_text_tokens)?; + } + if self.input_cached_text_tokens != 0 { + struct_ser.serialize_field("inputCachedTextTokens", &self.input_cached_text_tokens)?; + } + if self.input_image_tokens != 0 { + struct_ser.serialize_field("inputImageTokens", &self.input_image_tokens)?; + } + if self.input_cached_image_tokens != 0 { + struct_ser.serialize_field("inputCachedImageTokens", &self.input_cached_image_tokens)?; + } + if self.output_tokens != 0 { + struct_ser.serialize_field("outputTokens", &self.output_tokens)?; + } + if self.output_audio_tokens != 0 { + struct_ser.serialize_field("outputAudioTokens", &self.output_audio_tokens)?; + } + if self.output_text_tokens != 0 { + struct_ser.serialize_field("outputTextTokens", &self.output_text_tokens)?; + } + if self.session_duration != 0. { + struct_ser.serialize_field("sessionDuration", &self.session_duration)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LlmModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provider", + "model", + "input_tokens", + "inputTokens", + "input_cached_tokens", + "inputCachedTokens", + "input_audio_tokens", + "inputAudioTokens", + "input_cached_audio_tokens", + "inputCachedAudioTokens", + "input_text_tokens", + "inputTextTokens", + "input_cached_text_tokens", + "inputCachedTextTokens", + "input_image_tokens", + "inputImageTokens", + "input_cached_image_tokens", + "inputCachedImageTokens", + "output_tokens", + "outputTokens", + "output_audio_tokens", + "outputAudioTokens", + "output_text_tokens", + "outputTextTokens", + "session_duration", + "sessionDuration", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Provider, + Model, + InputTokens, + InputCachedTokens, + InputAudioTokens, + InputCachedAudioTokens, + InputTextTokens, + InputCachedTextTokens, + InputImageTokens, + InputCachedImageTokens, + OutputTokens, + OutputAudioTokens, + OutputTextTokens, + SessionDuration, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provider" => Ok(GeneratedField::Provider), + "model" => Ok(GeneratedField::Model), + "inputTokens" | "input_tokens" => Ok(GeneratedField::InputTokens), + "inputCachedTokens" | "input_cached_tokens" => Ok(GeneratedField::InputCachedTokens), + "inputAudioTokens" | "input_audio_tokens" => Ok(GeneratedField::InputAudioTokens), + "inputCachedAudioTokens" | "input_cached_audio_tokens" => Ok(GeneratedField::InputCachedAudioTokens), + "inputTextTokens" | "input_text_tokens" => Ok(GeneratedField::InputTextTokens), + "inputCachedTextTokens" | "input_cached_text_tokens" => Ok(GeneratedField::InputCachedTextTokens), + "inputImageTokens" | "input_image_tokens" => Ok(GeneratedField::InputImageTokens), + "inputCachedImageTokens" | "input_cached_image_tokens" => Ok(GeneratedField::InputCachedImageTokens), + "outputTokens" | "output_tokens" => Ok(GeneratedField::OutputTokens), + "outputAudioTokens" | "output_audio_tokens" => Ok(GeneratedField::OutputAudioTokens), + "outputTextTokens" | "output_text_tokens" => Ok(GeneratedField::OutputTextTokens), + "sessionDuration" | "session_duration" => Ok(GeneratedField::SessionDuration), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LlmModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.LLMModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provider__ = None; + let mut model__ = None; + let mut input_tokens__ = None; + let mut input_cached_tokens__ = None; + let mut input_audio_tokens__ = None; + let mut input_cached_audio_tokens__ = None; + let mut input_text_tokens__ = None; + let mut input_cached_text_tokens__ = None; + let mut input_image_tokens__ = None; + let mut input_cached_image_tokens__ = None; + let mut output_tokens__ = None; + let mut output_audio_tokens__ = None; + let mut output_text_tokens__ = None; + let mut session_duration__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); + } + GeneratedField::Model => { + if model__.is_some() { + return Err(serde::de::Error::duplicate_field("model")); + } + model__ = Some(map_.next_value()?); + } + GeneratedField::InputTokens => { + if input_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputTokens")); + } + input_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputCachedTokens => { + if input_cached_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputCachedTokens")); + } + input_cached_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputAudioTokens => { + if input_audio_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputAudioTokens")); + } + input_audio_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputCachedAudioTokens => { + if input_cached_audio_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputCachedAudioTokens")); + } + input_cached_audio_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputTextTokens => { + if input_text_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputTextTokens")); + } + input_text_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputCachedTextTokens => { + if input_cached_text_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputCachedTextTokens")); + } + input_cached_text_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputImageTokens => { + if input_image_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputImageTokens")); + } + input_image_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::InputCachedImageTokens => { + if input_cached_image_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputCachedImageTokens")); + } + input_cached_image_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputTokens => { + if output_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("outputTokens")); + } + output_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputAudioTokens => { + if output_audio_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("outputAudioTokens")); + } + output_audio_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputTextTokens => { + if output_text_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("outputTextTokens")); + } + output_text_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::SessionDuration => { + if session_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionDuration")); + } + session_duration__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(LlmModelUsage { + provider: provider__.unwrap_or_default(), + model: model__.unwrap_or_default(), + input_tokens: input_tokens__.unwrap_or_default(), + input_cached_tokens: input_cached_tokens__.unwrap_or_default(), + input_audio_tokens: input_audio_tokens__.unwrap_or_default(), + input_cached_audio_tokens: input_cached_audio_tokens__.unwrap_or_default(), + input_text_tokens: input_text_tokens__.unwrap_or_default(), + input_cached_text_tokens: input_cached_text_tokens__.unwrap_or_default(), + input_image_tokens: input_image_tokens__.unwrap_or_default(), + input_cached_image_tokens: input_cached_image_tokens__.unwrap_or_default(), + output_tokens: output_tokens__.unwrap_or_default(), + output_audio_tokens: output_audio_tokens__.unwrap_or_default(), + output_text_tokens: output_text_tokens__.unwrap_or_default(), + session_duration: session_duration__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.LLMModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MetricsReport { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.started_speaking_at.is_some() { + len += 1; + } + if self.stopped_speaking_at.is_some() { + len += 1; + } + if self.transcription_delay.is_some() { + len += 1; + } + if self.end_of_turn_delay.is_some() { + len += 1; + } + if self.on_user_turn_completed_delay.is_some() { + len += 1; + } + if self.llm_node_ttft.is_some() { + len += 1; + } + if self.tts_node_ttfb.is_some() { + len += 1; + } + if self.e2e_latency.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.MetricsReport", len)?; + if let Some(v) = self.started_speaking_at.as_ref() { + struct_ser.serialize_field("startedSpeakingAt", v)?; + } + if let Some(v) = self.stopped_speaking_at.as_ref() { + struct_ser.serialize_field("stoppedSpeakingAt", v)?; + } + if let Some(v) = self.transcription_delay.as_ref() { + struct_ser.serialize_field("transcriptionDelay", v)?; + } + if let Some(v) = self.end_of_turn_delay.as_ref() { + struct_ser.serialize_field("endOfTurnDelay", v)?; + } + if let Some(v) = self.on_user_turn_completed_delay.as_ref() { + struct_ser.serialize_field("onUserTurnCompletedDelay", v)?; + } + if let Some(v) = self.llm_node_ttft.as_ref() { + struct_ser.serialize_field("llmNodeTtft", v)?; + } + if let Some(v) = self.tts_node_ttfb.as_ref() { + struct_ser.serialize_field("ttsNodeTtfb", v)?; + } + if let Some(v) = self.e2e_latency.as_ref() { + struct_ser.serialize_field("e2eLatency", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MetricsReport { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "started_speaking_at", + "startedSpeakingAt", + "stopped_speaking_at", + "stoppedSpeakingAt", + "transcription_delay", + "transcriptionDelay", + "end_of_turn_delay", + "endOfTurnDelay", + "on_user_turn_completed_delay", + "onUserTurnCompletedDelay", + "llm_node_ttft", + "llmNodeTtft", + "tts_node_ttfb", + "ttsNodeTtfb", + "e2e_latency", + "e2eLatency", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + StartedSpeakingAt, + StoppedSpeakingAt, + TranscriptionDelay, + EndOfTurnDelay, + OnUserTurnCompletedDelay, + LlmNodeTtft, + TtsNodeTtfb, + E2eLatency, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "startedSpeakingAt" | "started_speaking_at" => Ok(GeneratedField::StartedSpeakingAt), + "stoppedSpeakingAt" | "stopped_speaking_at" => Ok(GeneratedField::StoppedSpeakingAt), + "transcriptionDelay" | "transcription_delay" => Ok(GeneratedField::TranscriptionDelay), + "endOfTurnDelay" | "end_of_turn_delay" => Ok(GeneratedField::EndOfTurnDelay), + "onUserTurnCompletedDelay" | "on_user_turn_completed_delay" => Ok(GeneratedField::OnUserTurnCompletedDelay), + "llmNodeTtft" | "llm_node_ttft" => Ok(GeneratedField::LlmNodeTtft), + "ttsNodeTtfb" | "tts_node_ttfb" => Ok(GeneratedField::TtsNodeTtfb), + "e2eLatency" | "e2e_latency" => Ok(GeneratedField::E2eLatency), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MetricsReport; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.MetricsReport") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut started_speaking_at__ = None; + let mut stopped_speaking_at__ = None; + let mut transcription_delay__ = None; + let mut end_of_turn_delay__ = None; + let mut on_user_turn_completed_delay__ = None; + let mut llm_node_ttft__ = None; + let mut tts_node_ttfb__ = None; + let mut e2e_latency__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::StartedSpeakingAt => { + if started_speaking_at__.is_some() { + return Err(serde::de::Error::duplicate_field("startedSpeakingAt")); + } + started_speaking_at__ = map_.next_value()?; + } + GeneratedField::StoppedSpeakingAt => { + if stopped_speaking_at__.is_some() { + return Err(serde::de::Error::duplicate_field("stoppedSpeakingAt")); + } + stopped_speaking_at__ = map_.next_value()?; + } + GeneratedField::TranscriptionDelay => { + if transcription_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("transcriptionDelay")); + } + transcription_delay__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::EndOfTurnDelay => { + if end_of_turn_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("endOfTurnDelay")); + } + end_of_turn_delay__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::OnUserTurnCompletedDelay => { + if on_user_turn_completed_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("onUserTurnCompletedDelay")); + } + on_user_turn_completed_delay__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::LlmNodeTtft => { + if llm_node_ttft__.is_some() { + return Err(serde::de::Error::duplicate_field("llmNodeTtft")); + } + llm_node_ttft__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::TtsNodeTtfb => { + if tts_node_ttfb__.is_some() { + return Err(serde::de::Error::duplicate_field("ttsNodeTtfb")); + } + tts_node_ttfb__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::E2eLatency => { + if e2e_latency__.is_some() { + return Err(serde::de::Error::duplicate_field("e2eLatency")); + } + e2e_latency__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(MetricsReport { + started_speaking_at: started_speaking_at__, + stopped_speaking_at: stopped_speaking_at__, + transcription_delay: transcription_delay__, + end_of_turn_delay: end_of_turn_delay__, + on_user_turn_completed_delay: on_user_turn_completed_delay__, + llm_node_ttft: llm_node_ttft__, + tts_node_ttfb: tts_node_ttfb__, + e2e_latency: e2e_latency__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.MetricsReport", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.usage.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ModelUsage", len)?; + if let Some(v) = self.usage.as_ref() { + match v { + model_usage::Usage::Llm(v) => { + struct_ser.serialize_field("llm", v)?; + } + model_usage::Usage::Tts(v) => { + struct_ser.serialize_field("tts", v)?; + } + model_usage::Usage::Stt(v) => { + struct_ser.serialize_field("stt", v)?; + } + model_usage::Usage::Interruption(v) => { + struct_ser.serialize_field("interruption", v)?; + } + model_usage::Usage::Eot(v) => { + struct_ser.serialize_field("eot", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "llm", + "tts", + "stt", + "interruption", + "eot", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Llm, + Tts, + Stt, + Interruption, + Eot, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "llm" => Ok(GeneratedField::Llm), + "tts" => Ok(GeneratedField::Tts), + "stt" => Ok(GeneratedField::Stt), + "interruption" => Ok(GeneratedField::Interruption), + "eot" => Ok(GeneratedField::Eot), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut usage__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Llm => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("llm")); + } + usage__ = map_.next_value::<::std::option::Option<_>>()?.map(model_usage::Usage::Llm) +; + } + GeneratedField::Tts => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("tts")); + } + usage__ = map_.next_value::<::std::option::Option<_>>()?.map(model_usage::Usage::Tts) +; + } + GeneratedField::Stt => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("stt")); + } + usage__ = map_.next_value::<::std::option::Option<_>>()?.map(model_usage::Usage::Stt) +; + } + GeneratedField::Interruption => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("interruption")); + } + usage__ = map_.next_value::<::std::option::Option<_>>()?.map(model_usage::Usage::Interruption) +; + } + GeneratedField::Eot => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("eot")); + } + usage__ = map_.next_value::<::std::option::Option<_>>()?.map(model_usage::Usage::Eot) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ModelUsage { + usage: usage__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RunningAgentJobInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.job.is_empty() { + len += 1; + } + if !self.accept_name.is_empty() { + len += 1; + } + if !self.accept_identity.is_empty() { + len += 1; + } + if !self.accept_metadata.is_empty() { + len += 1; + } + if !self.url.is_empty() { + len += 1; + } + if !self.token.is_empty() { + len += 1; + } + if !self.worker_id.is_empty() { + len += 1; + } + if self.mock_job { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.RunningAgentJobInfo", len)?; + if !self.job.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("job", pbjson::private::base64::encode(&self.job).as_str())?; + } + if !self.accept_name.is_empty() { + struct_ser.serialize_field("acceptName", &self.accept_name)?; + } + if !self.accept_identity.is_empty() { + struct_ser.serialize_field("acceptIdentity", &self.accept_identity)?; + } + if !self.accept_metadata.is_empty() { + struct_ser.serialize_field("acceptMetadata", &self.accept_metadata)?; + } + if !self.url.is_empty() { + struct_ser.serialize_field("url", &self.url)?; + } + if !self.token.is_empty() { + struct_ser.serialize_field("token", &self.token)?; + } + if !self.worker_id.is_empty() { + struct_ser.serialize_field("workerId", &self.worker_id)?; + } + if self.mock_job { + struct_ser.serialize_field("mockJob", &self.mock_job)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RunningAgentJobInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "job", + "accept_name", + "acceptName", + "accept_identity", + "acceptIdentity", + "accept_metadata", + "acceptMetadata", + "url", + "token", + "worker_id", + "workerId", + "mock_job", + "mockJob", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Job, + AcceptName, + AcceptIdentity, + AcceptMetadata, + Url, + Token, + WorkerId, + MockJob, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "job" => Ok(GeneratedField::Job), + "acceptName" | "accept_name" => Ok(GeneratedField::AcceptName), + "acceptIdentity" | "accept_identity" => Ok(GeneratedField::AcceptIdentity), + "acceptMetadata" | "accept_metadata" => Ok(GeneratedField::AcceptMetadata), + "url" => Ok(GeneratedField::Url), + "token" => Ok(GeneratedField::Token), + "workerId" | "worker_id" => Ok(GeneratedField::WorkerId), + "mockJob" | "mock_job" => Ok(GeneratedField::MockJob), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RunningAgentJobInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.RunningAgentJobInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut job__ = None; + let mut accept_name__ = None; + let mut accept_identity__ = None; + let mut accept_metadata__ = None; + let mut url__ = None; + let mut token__ = None; + let mut worker_id__ = None; + let mut mock_job__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Job => { + if job__.is_some() { + return Err(serde::de::Error::duplicate_field("job")); + } + job__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::AcceptName => { + if accept_name__.is_some() { + return Err(serde::de::Error::duplicate_field("acceptName")); + } + accept_name__ = Some(map_.next_value()?); + } + GeneratedField::AcceptIdentity => { + if accept_identity__.is_some() { + return Err(serde::de::Error::duplicate_field("acceptIdentity")); + } + accept_identity__ = Some(map_.next_value()?); + } + GeneratedField::AcceptMetadata => { + if accept_metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("acceptMetadata")); + } + accept_metadata__ = Some(map_.next_value()?); + } + GeneratedField::Url => { + if url__.is_some() { + return Err(serde::de::Error::duplicate_field("url")); + } + url__ = Some(map_.next_value()?); + } + GeneratedField::Token => { + if token__.is_some() { + return Err(serde::de::Error::duplicate_field("token")); + } + token__ = Some(map_.next_value()?); + } + GeneratedField::WorkerId => { + if worker_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workerId")); + } + worker_id__ = Some(map_.next_value()?); + } + GeneratedField::MockJob => { + if mock_job__.is_some() { + return Err(serde::de::Error::duplicate_field("mockJob")); + } + mock_job__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(RunningAgentJobInfo { + job: job__.unwrap_or_default(), + accept_name: accept_name__.unwrap_or_default(), + accept_identity: accept_identity__.unwrap_or_default(), + accept_metadata: accept_metadata__.unwrap_or_default(), + url: url__.unwrap_or_default(), + token: token__.unwrap_or_default(), + worker_id: worker_id__.unwrap_or_default(), + mock_job: mock_job__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.RunningAgentJobInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SttModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.provider.is_empty() { + len += 1; + } + if !self.model.is_empty() { + len += 1; + } + if self.input_tokens != 0 { + len += 1; + } + if self.output_tokens != 0 { + len += 1; + } + if self.audio_duration != 0. { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.STTModelUsage", len)?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; + } + if !self.model.is_empty() { + struct_ser.serialize_field("model", &self.model)?; + } + if self.input_tokens != 0 { + struct_ser.serialize_field("inputTokens", &self.input_tokens)?; + } + if self.output_tokens != 0 { + struct_ser.serialize_field("outputTokens", &self.output_tokens)?; + } + if self.audio_duration != 0. { + struct_ser.serialize_field("audioDuration", &self.audio_duration)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SttModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provider", + "model", + "input_tokens", + "inputTokens", + "output_tokens", + "outputTokens", + "audio_duration", + "audioDuration", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Provider, + Model, + InputTokens, + OutputTokens, + AudioDuration, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provider" => Ok(GeneratedField::Provider), + "model" => Ok(GeneratedField::Model), + "inputTokens" | "input_tokens" => Ok(GeneratedField::InputTokens), + "outputTokens" | "output_tokens" => Ok(GeneratedField::OutputTokens), + "audioDuration" | "audio_duration" => Ok(GeneratedField::AudioDuration), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SttModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.STTModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provider__ = None; + let mut model__ = None; + let mut input_tokens__ = None; + let mut output_tokens__ = None; + let mut audio_duration__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); + } + GeneratedField::Model => { + if model__.is_some() { + return Err(serde::de::Error::duplicate_field("model")); + } + model__ = Some(map_.next_value()?); + } + GeneratedField::InputTokens => { + if input_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputTokens")); + } + input_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputTokens => { + if output_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("outputTokens")); + } + output_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::AudioDuration => { + if audio_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("audioDuration")); + } + audio_duration__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SttModelUsage { + provider: provider__.unwrap_or_default(), + model: model__.unwrap_or_default(), + input_tokens: input_tokens__.unwrap_or_default(), + output_tokens: output_tokens__.unwrap_or_default(), + audio_duration: audio_duration__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.STTModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ServerInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.agent_name.is_empty() { + len += 1; + } + if !self.url.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ServerInfo", len)?; + if !self.agent_name.is_empty() { + struct_ser.serialize_field("agentName", &self.agent_name)?; + } + if !self.url.is_empty() { + struct_ser.serialize_field("url", &self.url)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ServerInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "agent_name", + "agentName", + "url", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AgentName, + Url, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "agentName" | "agent_name" => Ok(GeneratedField::AgentName), + "url" => Ok(GeneratedField::Url), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ServerInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ServerInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut agent_name__ = None; + let mut url__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AgentName => { + if agent_name__.is_some() { + return Err(serde::de::Error::duplicate_field("agentName")); + } + agent_name__ = Some(map_.next_value()?); + } + GeneratedField::Url => { + if url__.is_some() { + return Err(serde::de::Error::duplicate_field("url")); + } + url__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ServerInfo { + agent_name: agent_name__.unwrap_or_default(), + url: url__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.ServerInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ServerMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.server_created_at.is_some() { + len += 1; + } + if self.request_id.is_some() { + len += 1; + } + if self.client_created_at.is_some() { + len += 1; + } + if self.message.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.ServerMessage", len)?; + if let Some(v) = self.server_created_at.as_ref() { + struct_ser.serialize_field("serverCreatedAt", v)?; + } + if let Some(v) = self.request_id.as_ref() { + struct_ser.serialize_field("requestId", v)?; + } + if let Some(v) = self.client_created_at.as_ref() { + struct_ser.serialize_field("clientCreatedAt", v)?; + } + if let Some(v) = self.message.as_ref() { + match v { + server_message::Message::SessionCreated(v) => { + struct_ser.serialize_field("sessionCreated", v)?; + } + server_message::Message::InferenceStarted(v) => { + struct_ser.serialize_field("inferenceStarted", v)?; + } + server_message::Message::InferenceStopped(v) => { + struct_ser.serialize_field("inferenceStopped", v)?; + } + server_message::Message::SessionClosed(v) => { + struct_ser.serialize_field("sessionClosed", v)?; + } + server_message::Message::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + server_message::Message::EotPrediction(v) => { + struct_ser.serialize_field("eotPrediction", v)?; + } + server_message::Message::InterruptionPrediction(v) => { + struct_ser.serialize_field("interruptionPrediction", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ServerMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "server_created_at", + "serverCreatedAt", + "request_id", + "requestId", + "client_created_at", + "clientCreatedAt", + "session_created", + "sessionCreated", + "inference_started", + "inferenceStarted", + "inference_stopped", + "inferenceStopped", + "session_closed", + "sessionClosed", + "error", + "eot_prediction", + "eotPrediction", + "interruption_prediction", + "interruptionPrediction", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ServerCreatedAt, + RequestId, + ClientCreatedAt, + SessionCreated, + InferenceStarted, + InferenceStopped, + SessionClosed, + Error, + EotPrediction, + InterruptionPrediction, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "serverCreatedAt" | "server_created_at" => Ok(GeneratedField::ServerCreatedAt), + "requestId" | "request_id" => Ok(GeneratedField::RequestId), + "clientCreatedAt" | "client_created_at" => Ok(GeneratedField::ClientCreatedAt), + "sessionCreated" | "session_created" => Ok(GeneratedField::SessionCreated), + "inferenceStarted" | "inference_started" => Ok(GeneratedField::InferenceStarted), + "inferenceStopped" | "inference_stopped" => Ok(GeneratedField::InferenceStopped), + "sessionClosed" | "session_closed" => Ok(GeneratedField::SessionClosed), + "error" => Ok(GeneratedField::Error), + "eotPrediction" | "eot_prediction" => Ok(GeneratedField::EotPrediction), + "interruptionPrediction" | "interruption_prediction" => Ok(GeneratedField::InterruptionPrediction), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ServerMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.ServerMessage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut server_created_at__ = None; + let mut request_id__ = None; + let mut client_created_at__ = None; + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ServerCreatedAt => { + if server_created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("serverCreatedAt")); + } + server_created_at__ = map_.next_value()?; + } + GeneratedField::RequestId => { + if request_id__.is_some() { + return Err(serde::de::Error::duplicate_field("requestId")); + } + request_id__ = map_.next_value()?; + } + GeneratedField::ClientCreatedAt => { + if client_created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("clientCreatedAt")); + } + client_created_at__ = map_.next_value()?; + } + GeneratedField::SessionCreated => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionCreated")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::SessionCreated) +; + } + GeneratedField::InferenceStarted => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStarted")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::InferenceStarted) +; + } + GeneratedField::InferenceStopped => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("inferenceStopped")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::InferenceStopped) +; + } + GeneratedField::SessionClosed => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionClosed")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::SessionClosed) +; + } + GeneratedField::Error => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::Error) +; + } + GeneratedField::EotPrediction => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("eotPrediction")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::EotPrediction) +; + } + GeneratedField::InterruptionPrediction => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("interruptionPrediction")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::InterruptionPrediction) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ServerMessage { + server_created_at: server_created_at__, + request_id: request_id__, + client_created_at: client_created_at__, + message: message__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.ServerMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionClose { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionClose", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionClose { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionClose; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionClose") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SessionClose { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionClose", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionClosed { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionClosed", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionClosed { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionClosed; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionClosed") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SessionClosed { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionClosed", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionCreate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.settings.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionCreate", len)?; + if let Some(v) = self.settings.as_ref() { + struct_ser.serialize_field("settings", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionCreate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "settings", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Settings, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "settings" => Ok(GeneratedField::Settings), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionCreate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionCreate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut settings__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Settings => { + if settings__.is_some() { + return Err(serde::de::Error::duplicate_field("settings")); + } + settings__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SessionCreate { + settings: settings__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionCreate", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionCreated { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.default_thresholds.is_empty() { + len += 1; + } + if self.default_threshold != 0. { + len += 1; + } + if !self.default_backchannel_thresholds.is_empty() { + len += 1; + } + if self.default_backchannel_threshold != 0. { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionCreated", len)?; + if !self.default_thresholds.is_empty() { + struct_ser.serialize_field("defaultThresholds", &self.default_thresholds)?; + } + if self.default_threshold != 0. { + struct_ser.serialize_field("defaultThreshold", &self.default_threshold)?; + } + if !self.default_backchannel_thresholds.is_empty() { + struct_ser.serialize_field("defaultBackchannelThresholds", &self.default_backchannel_thresholds)?; + } + if self.default_backchannel_threshold != 0. { + struct_ser.serialize_field("defaultBackchannelThreshold", &self.default_backchannel_threshold)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionCreated { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "default_thresholds", + "defaultThresholds", + "default_threshold", + "defaultThreshold", + "default_backchannel_thresholds", + "defaultBackchannelThresholds", + "default_backchannel_threshold", + "defaultBackchannelThreshold", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + DefaultThresholds, + DefaultThreshold, + DefaultBackchannelThresholds, + DefaultBackchannelThreshold, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "defaultThresholds" | "default_thresholds" => Ok(GeneratedField::DefaultThresholds), + "defaultThreshold" | "default_threshold" => Ok(GeneratedField::DefaultThreshold), + "defaultBackchannelThresholds" | "default_backchannel_thresholds" => Ok(GeneratedField::DefaultBackchannelThresholds), + "defaultBackchannelThreshold" | "default_backchannel_threshold" => Ok(GeneratedField::DefaultBackchannelThreshold), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionCreated; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionCreated") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut default_thresholds__ = None; + let mut default_threshold__ = None; + let mut default_backchannel_thresholds__ = None; + let mut default_backchannel_threshold__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::DefaultThresholds => { + if default_thresholds__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultThresholds")); + } + default_thresholds__ = Some( + map_.next_value::>>()? + .into_iter().map(|(k,v)| (k, v.0)).collect() + ); + } + GeneratedField::DefaultThreshold => { + if default_threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultThreshold")); + } + default_threshold__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::DefaultBackchannelThresholds => { + if default_backchannel_thresholds__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultBackchannelThresholds")); + } + default_backchannel_thresholds__ = Some( + map_.next_value::>>()? + .into_iter().map(|(k,v)| (k, v.0)).collect() + ); + } + GeneratedField::DefaultBackchannelThreshold => { + if default_backchannel_threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultBackchannelThreshold")); + } + default_backchannel_threshold__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SessionCreated { + default_thresholds: default_thresholds__.unwrap_or_default(), + default_threshold: default_threshold__.unwrap_or_default(), + default_backchannel_thresholds: default_backchannel_thresholds__.unwrap_or_default(), + default_backchannel_threshold: default_backchannel_threshold__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionCreated", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionFlush { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionFlush", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionFlush { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionFlush; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionFlush") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SessionFlush { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionFlush", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.request_id.is_empty() { + len += 1; + } + if self.request.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest", len)?; + if !self.request_id.is_empty() { + struct_ser.serialize_field("requestId", &self.request_id)?; + } + if let Some(v) = self.request.as_ref() { + match v { + session_request::Request::Ping(v) => { + struct_ser.serialize_field("ping", v)?; + } + session_request::Request::GetChatHistory(v) => { + struct_ser.serialize_field("getChatHistory", v)?; + } + session_request::Request::RunInput(v) => { + struct_ser.serialize_field("runInput", v)?; + } + session_request::Request::GetAgentInfo(v) => { + struct_ser.serialize_field("getAgentInfo", v)?; + } + session_request::Request::GetSessionState(v) => { + struct_ser.serialize_field("getSessionState", v)?; + } + session_request::Request::GetRtcStats(v) => { + struct_ser.serialize_field("getRtcStats", v)?; + } + session_request::Request::GetSessionUsage(v) => { + struct_ser.serialize_field("getSessionUsage", v)?; + } + session_request::Request::GetFrameworkInfo(v) => { + struct_ser.serialize_field("getFrameworkInfo", v)?; + } + session_request::Request::UpdateIo(v) => { + struct_ser.serialize_field("updateIo", v)?; + } + session_request::Request::FinalizeSimulation(v) => { + struct_ser.serialize_field("finalizeSimulation", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "request_id", + "requestId", + "ping", + "get_chat_history", + "getChatHistory", + "run_input", + "runInput", + "get_agent_info", + "getAgentInfo", + "get_session_state", + "getSessionState", + "get_rtc_stats", + "getRtcStats", + "get_session_usage", + "getSessionUsage", + "get_framework_info", + "getFrameworkInfo", + "update_io", + "updateIo", + "finalize_simulation", + "finalizeSimulation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + RequestId, + Ping, + GetChatHistory, + RunInput, + GetAgentInfo, + GetSessionState, + GetRtcStats, + GetSessionUsage, + GetFrameworkInfo, + UpdateIo, + FinalizeSimulation, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requestId" | "request_id" => Ok(GeneratedField::RequestId), + "ping" => Ok(GeneratedField::Ping), + "getChatHistory" | "get_chat_history" => Ok(GeneratedField::GetChatHistory), + "runInput" | "run_input" => Ok(GeneratedField::RunInput), + "getAgentInfo" | "get_agent_info" => Ok(GeneratedField::GetAgentInfo), + "getSessionState" | "get_session_state" => Ok(GeneratedField::GetSessionState), + "getRtcStats" | "get_rtc_stats" => Ok(GeneratedField::GetRtcStats), + "getSessionUsage" | "get_session_usage" => Ok(GeneratedField::GetSessionUsage), + "getFrameworkInfo" | "get_framework_info" => Ok(GeneratedField::GetFrameworkInfo), + "updateIo" | "update_io" => Ok(GeneratedField::UpdateIo), + "finalizeSimulation" | "finalize_simulation" => Ok(GeneratedField::FinalizeSimulation), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut request_id__ = None; + let mut request__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::RequestId => { + if request_id__.is_some() { + return Err(serde::de::Error::duplicate_field("requestId")); + } + request_id__ = Some(map_.next_value()?); + } + GeneratedField::Ping => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("ping")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::Ping) +; + } + GeneratedField::GetChatHistory => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getChatHistory")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetChatHistory) +; + } + GeneratedField::RunInput => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("runInput")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::RunInput) +; + } + GeneratedField::GetAgentInfo => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getAgentInfo")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetAgentInfo) +; + } + GeneratedField::GetSessionState => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getSessionState")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetSessionState) +; + } + GeneratedField::GetRtcStats => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getRtcStats")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetRtcStats) +; + } + GeneratedField::GetSessionUsage => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getSessionUsage")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetSessionUsage) +; + } + GeneratedField::GetFrameworkInfo => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("getFrameworkInfo")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::GetFrameworkInfo) +; + } + GeneratedField::UpdateIo => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("updateIo")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::UpdateIo) +; + } + GeneratedField::FinalizeSimulation => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("finalizeSimulation")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(session_request::Request::FinalizeSimulation) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SessionRequest { + request_id: request_id__.unwrap_or_default(), + request: request__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::FinalizeSimulation { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.provisional_success { + len += 1; + } + if !self.provisional_reason.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.FinalizeSimulation", len)?; + if self.provisional_success { + struct_ser.serialize_field("provisionalSuccess", &self.provisional_success)?; + } + if !self.provisional_reason.is_empty() { + struct_ser.serialize_field("provisionalReason", &self.provisional_reason)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::FinalizeSimulation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provisional_success", + "provisionalSuccess", + "provisional_reason", + "provisionalReason", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ProvisionalSuccess, + ProvisionalReason, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provisionalSuccess" | "provisional_success" => Ok(GeneratedField::ProvisionalSuccess), + "provisionalReason" | "provisional_reason" => Ok(GeneratedField::ProvisionalReason), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::FinalizeSimulation; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.FinalizeSimulation") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provisional_success__ = None; + let mut provisional_reason__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ProvisionalSuccess => { + if provisional_success__.is_some() { + return Err(serde::de::Error::duplicate_field("provisionalSuccess")); + } + provisional_success__ = Some(map_.next_value()?); + } + GeneratedField::ProvisionalReason => { + if provisional_reason__.is_some() { + return Err(serde::de::Error::duplicate_field("provisionalReason")); + } + provisional_reason__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_request::FinalizeSimulation { + provisional_success: provisional_success__.unwrap_or_default(), + provisional_reason: provisional_reason__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.FinalizeSimulation", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetAgentInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetAgentInfo", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetAgentInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetAgentInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetAgentInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetAgentInfo { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetAgentInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetChatHistory { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetChatHistory", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetChatHistory { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetChatHistory; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetChatHistory") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetChatHistory { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetChatHistory", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetFrameworkInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetFrameworkInfo", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetFrameworkInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetFrameworkInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetFrameworkInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetFrameworkInfo { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetFrameworkInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetRtcStats { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetRTCStats", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetRtcStats { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetRtcStats; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetRTCStats") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetRtcStats { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetRTCStats", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetSessionState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetSessionState", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetSessionState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetSessionState; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetSessionState") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetSessionState { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetSessionState", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::GetSessionUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.GetSessionUsage", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::GetSessionUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::GetSessionUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.GetSessionUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::GetSessionUsage { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.GetSessionUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::Ping { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.Ping", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::Ping { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::Ping; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.Ping") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_request::Ping { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.Ping", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::RunInput { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.text.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.RunInput", len)?; + if !self.text.is_empty() { + struct_ser.serialize_field("text", &self.text)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::RunInput { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "text", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Text, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "text" => Ok(GeneratedField::Text), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::RunInput; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.RunInput") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut text__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Text => { + if text__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + text__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_request::RunInput { + text: text__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.RunInput", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::UpdateIo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.output.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.UpdateIO", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.output.as_ref() { + struct_ser.serialize_field("output", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::UpdateIo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "output", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Output, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "output" => Ok(GeneratedField::Output), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::UpdateIo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.UpdateIO") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut output__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map_.next_value()?; + } + GeneratedField::Output => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("output")); + } + output__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_request::UpdateIo { + input: input__, + output: output__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.UpdateIO", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::update_io::Input { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.audio_enabled.is_some() { + len += 1; + } + if self.video_enabled.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.UpdateIO.Input", len)?; + if let Some(v) = self.audio_enabled.as_ref() { + struct_ser.serialize_field("audioEnabled", v)?; + } + if let Some(v) = self.video_enabled.as_ref() { + struct_ser.serialize_field("videoEnabled", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::update_io::Input { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio_enabled", + "audioEnabled", + "video_enabled", + "videoEnabled", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AudioEnabled, + VideoEnabled, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audioEnabled" | "audio_enabled" => Ok(GeneratedField::AudioEnabled), + "videoEnabled" | "video_enabled" => Ok(GeneratedField::VideoEnabled), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::update_io::Input; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.UpdateIO.Input") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut audio_enabled__ = None; + let mut video_enabled__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AudioEnabled => { + if audio_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("audioEnabled")); + } + audio_enabled__ = map_.next_value()?; + } + GeneratedField::VideoEnabled => { + if video_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("videoEnabled")); + } + video_enabled__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_request::update_io::Input { + audio_enabled: audio_enabled__, + video_enabled: video_enabled__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.UpdateIO.Input", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_request::update_io::Output { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.audio_enabled.is_some() { + len += 1; + } + if self.video_enabled.is_some() { + len += 1; + } + if self.transcription_enabled.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionRequest.UpdateIO.Output", len)?; + if let Some(v) = self.audio_enabled.as_ref() { + struct_ser.serialize_field("audioEnabled", v)?; + } + if let Some(v) = self.video_enabled.as_ref() { + struct_ser.serialize_field("videoEnabled", v)?; + } + if let Some(v) = self.transcription_enabled.as_ref() { + struct_ser.serialize_field("transcriptionEnabled", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_request::update_io::Output { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "audio_enabled", + "audioEnabled", + "video_enabled", + "videoEnabled", + "transcription_enabled", + "transcriptionEnabled", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AudioEnabled, + VideoEnabled, + TranscriptionEnabled, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "audioEnabled" | "audio_enabled" => Ok(GeneratedField::AudioEnabled), + "videoEnabled" | "video_enabled" => Ok(GeneratedField::VideoEnabled), + "transcriptionEnabled" | "transcription_enabled" => Ok(GeneratedField::TranscriptionEnabled), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_request::update_io::Output; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionRequest.UpdateIO.Output") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut audio_enabled__ = None; + let mut video_enabled__ = None; + let mut transcription_enabled__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AudioEnabled => { + if audio_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("audioEnabled")); + } + audio_enabled__ = map_.next_value()?; + } + GeneratedField::VideoEnabled => { + if video_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("videoEnabled")); + } + video_enabled__ = map_.next_value()?; + } + GeneratedField::TranscriptionEnabled => { + if transcription_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("transcriptionEnabled")); + } + transcription_enabled__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_request::update_io::Output { + audio_enabled: audio_enabled__, + video_enabled: video_enabled__, + transcription_enabled: transcription_enabled__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionRequest.UpdateIO.Output", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.request_id.is_empty() { + len += 1; + } + if self.error.is_some() { + len += 1; + } + if self.response.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse", len)?; + if !self.request_id.is_empty() { + struct_ser.serialize_field("requestId", &self.request_id)?; + } + if let Some(v) = self.error.as_ref() { + struct_ser.serialize_field("error", v)?; + } + if let Some(v) = self.response.as_ref() { + match v { + session_response::Response::Pong(v) => { + struct_ser.serialize_field("pong", v)?; + } + session_response::Response::GetChatHistory(v) => { + struct_ser.serialize_field("getChatHistory", v)?; + } + session_response::Response::RunInput(v) => { + struct_ser.serialize_field("runInput", v)?; + } + session_response::Response::GetAgentInfo(v) => { + struct_ser.serialize_field("getAgentInfo", v)?; + } + session_response::Response::GetSessionState(v) => { + struct_ser.serialize_field("getSessionState", v)?; + } + session_response::Response::GetRtcStats(v) => { + struct_ser.serialize_field("getRtcStats", v)?; + } + session_response::Response::GetSessionUsage(v) => { + struct_ser.serialize_field("getSessionUsage", v)?; + } + session_response::Response::GetFrameworkInfo(v) => { + struct_ser.serialize_field("getFrameworkInfo", v)?; + } + session_response::Response::UpdateIo(v) => { + struct_ser.serialize_field("updateIo", v)?; + } + session_response::Response::FinalizeSimulation(v) => { + struct_ser.serialize_field("finalizeSimulation", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "request_id", + "requestId", + "error", + "pong", + "get_chat_history", + "getChatHistory", + "run_input", + "runInput", + "get_agent_info", + "getAgentInfo", + "get_session_state", + "getSessionState", + "get_rtc_stats", + "getRtcStats", + "get_session_usage", + "getSessionUsage", + "get_framework_info", + "getFrameworkInfo", + "update_io", + "updateIo", + "finalize_simulation", + "finalizeSimulation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + RequestId, + Error, + Pong, + GetChatHistory, + RunInput, + GetAgentInfo, + GetSessionState, + GetRtcStats, + GetSessionUsage, + GetFrameworkInfo, + UpdateIo, + FinalizeSimulation, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requestId" | "request_id" => Ok(GeneratedField::RequestId), + "error" => Ok(GeneratedField::Error), + "pong" => Ok(GeneratedField::Pong), + "getChatHistory" | "get_chat_history" => Ok(GeneratedField::GetChatHistory), + "runInput" | "run_input" => Ok(GeneratedField::RunInput), + "getAgentInfo" | "get_agent_info" => Ok(GeneratedField::GetAgentInfo), + "getSessionState" | "get_session_state" => Ok(GeneratedField::GetSessionState), + "getRtcStats" | "get_rtc_stats" => Ok(GeneratedField::GetRtcStats), + "getSessionUsage" | "get_session_usage" => Ok(GeneratedField::GetSessionUsage), + "getFrameworkInfo" | "get_framework_info" => Ok(GeneratedField::GetFrameworkInfo), + "updateIo" | "update_io" => Ok(GeneratedField::UpdateIo), + "finalizeSimulation" | "finalize_simulation" => Ok(GeneratedField::FinalizeSimulation), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut request_id__ = None; + let mut error__ = None; + let mut response__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::RequestId => { + if request_id__.is_some() { + return Err(serde::de::Error::duplicate_field("requestId")); + } + request_id__ = Some(map_.next_value()?); + } + GeneratedField::Error => { + if error__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + error__ = map_.next_value()?; + } + GeneratedField::Pong => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("pong")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::Pong) +; + } + GeneratedField::GetChatHistory => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getChatHistory")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetChatHistory) +; + } + GeneratedField::RunInput => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("runInput")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::RunInput) +; + } + GeneratedField::GetAgentInfo => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getAgentInfo")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetAgentInfo) +; + } + GeneratedField::GetSessionState => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getSessionState")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetSessionState) +; + } + GeneratedField::GetRtcStats => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getRtcStats")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetRtcStats) +; + } + GeneratedField::GetSessionUsage => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getSessionUsage")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetSessionUsage) +; + } + GeneratedField::GetFrameworkInfo => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("getFrameworkInfo")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::GetFrameworkInfo) +; + } + GeneratedField::UpdateIo => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("updateIo")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::UpdateIo) +; + } + GeneratedField::FinalizeSimulation => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("finalizeSimulation")); + } + response__ = map_.next_value::<::std::option::Option<_>>()?.map(session_response::Response::FinalizeSimulation) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SessionResponse { + request_id: request_id__.unwrap_or_default(), + error: error__, + response: response__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::FinalizeSimulationResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.user_verdict.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.FinalizeSimulationResponse", len)?; + if let Some(v) = self.user_verdict.as_ref() { + struct_ser.serialize_field("userVerdict", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::FinalizeSimulationResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "user_verdict", + "userVerdict", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + UserVerdict, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "userVerdict" | "user_verdict" => Ok(GeneratedField::UserVerdict), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::FinalizeSimulationResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.FinalizeSimulationResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut user_verdict__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::UserVerdict => { + if user_verdict__.is_some() { + return Err(serde::de::Error::duplicate_field("userVerdict")); + } + user_verdict__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::FinalizeSimulationResponse { + user_verdict: user_verdict__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.FinalizeSimulationResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::finalize_simulation_response::SimulationVerdict { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.success { + len += 1; + } + if !self.reason.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.FinalizeSimulationResponse.SimulationVerdict", len)?; + if self.success { + struct_ser.serialize_field("success", &self.success)?; + } + if !self.reason.is_empty() { + struct_ser.serialize_field("reason", &self.reason)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::finalize_simulation_response::SimulationVerdict { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "success", + "reason", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Success, + Reason, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "success" => Ok(GeneratedField::Success), + "reason" => Ok(GeneratedField::Reason), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::finalize_simulation_response::SimulationVerdict; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.FinalizeSimulationResponse.SimulationVerdict") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut success__ = None; + let mut reason__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Success => { + if success__.is_some() { + return Err(serde::de::Error::duplicate_field("success")); + } + success__ = Some(map_.next_value()?); + } + GeneratedField::Reason => { + if reason__.is_some() { + return Err(serde::de::Error::duplicate_field("reason")); + } + reason__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::finalize_simulation_response::SimulationVerdict { + success: success__.unwrap_or_default(), + reason: reason__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.FinalizeSimulationResponse.SimulationVerdict", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetAgentInfoResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.instructions.is_some() { + len += 1; + } + if !self.tools.is_empty() { + len += 1; + } + if !self.chat_ctx.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetAgentInfoResponse", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.instructions.as_ref() { + struct_ser.serialize_field("instructions", v)?; + } + if !self.tools.is_empty() { + struct_ser.serialize_field("tools", &self.tools)?; + } + if !self.chat_ctx.is_empty() { + struct_ser.serialize_field("chatCtx", &self.chat_ctx)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetAgentInfoResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "instructions", + "tools", + "chat_ctx", + "chatCtx", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Instructions, + Tools, + ChatCtx, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "instructions" => Ok(GeneratedField::Instructions), + "tools" => Ok(GeneratedField::Tools), + "chatCtx" | "chat_ctx" => Ok(GeneratedField::ChatCtx), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetAgentInfoResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetAgentInfoResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut instructions__ = None; + let mut tools__ = None; + let mut chat_ctx__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Instructions => { + if instructions__.is_some() { + return Err(serde::de::Error::duplicate_field("instructions")); + } + instructions__ = map_.next_value()?; + } + GeneratedField::Tools => { + if tools__.is_some() { + return Err(serde::de::Error::duplicate_field("tools")); + } + tools__ = Some(map_.next_value()?); + } + GeneratedField::ChatCtx => { + if chat_ctx__.is_some() { + return Err(serde::de::Error::duplicate_field("chatCtx")); + } + chat_ctx__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetAgentInfoResponse { + id: id__.unwrap_or_default(), + instructions: instructions__, + tools: tools__.unwrap_or_default(), + chat_ctx: chat_ctx__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetAgentInfoResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetChatHistoryResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.items.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetChatHistoryResponse", len)?; + if !self.items.is_empty() { + struct_ser.serialize_field("items", &self.items)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetChatHistoryResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "items", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Items, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "items" => Ok(GeneratedField::Items), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetChatHistoryResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetChatHistoryResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut items__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Items => { + if items__.is_some() { + return Err(serde::de::Error::duplicate_field("items")); + } + items__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetChatHistoryResponse { + items: items__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetChatHistoryResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetFrameworkInfoResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sdk.is_empty() { + len += 1; + } + if !self.sdk_version.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetFrameworkInfoResponse", len)?; + if !self.sdk.is_empty() { + struct_ser.serialize_field("sdk", &self.sdk)?; + } + if !self.sdk_version.is_empty() { + struct_ser.serialize_field("sdkVersion", &self.sdk_version)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetFrameworkInfoResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sdk", + "sdk_version", + "sdkVersion", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sdk, + SdkVersion, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sdk" => Ok(GeneratedField::Sdk), + "sdkVersion" | "sdk_version" => Ok(GeneratedField::SdkVersion), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetFrameworkInfoResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetFrameworkInfoResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sdk__ = None; + let mut sdk_version__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Sdk => { + if sdk__.is_some() { + return Err(serde::de::Error::duplicate_field("sdk")); + } + sdk__ = Some(map_.next_value()?); + } + GeneratedField::SdkVersion => { + if sdk_version__.is_some() { + return Err(serde::de::Error::duplicate_field("sdkVersion")); + } + sdk_version__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetFrameworkInfoResponse { + sdk: sdk__.unwrap_or_default(), + sdk_version: sdk_version__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetFrameworkInfoResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetRtcStatsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.publisher_stats.is_empty() { + len += 1; + } + if !self.subscriber_stats.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetRTCStatsResponse", len)?; + if !self.publisher_stats.is_empty() { + struct_ser.serialize_field("publisherStats", &self.publisher_stats)?; + } + if !self.subscriber_stats.is_empty() { + struct_ser.serialize_field("subscriberStats", &self.subscriber_stats)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetRtcStatsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "publisher_stats", + "publisherStats", + "subscriber_stats", + "subscriberStats", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PublisherStats, + SubscriberStats, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "publisherStats" | "publisher_stats" => Ok(GeneratedField::PublisherStats), + "subscriberStats" | "subscriber_stats" => Ok(GeneratedField::SubscriberStats), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetRtcStatsResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetRTCStatsResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut publisher_stats__ = None; + let mut subscriber_stats__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PublisherStats => { + if publisher_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("publisherStats")); + } + publisher_stats__ = Some(map_.next_value()?); + } + GeneratedField::SubscriberStats => { + if subscriber_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("subscriberStats")); + } + subscriber_stats__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetRtcStatsResponse { + publisher_stats: publisher_stats__.unwrap_or_default(), + subscriber_stats: subscriber_stats__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetRTCStatsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetSessionStateResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.agent_state != 0 { + len += 1; + } + if self.user_state != 0 { + len += 1; + } + if !self.agent_id.is_empty() { + len += 1; + } + if !self.options.is_empty() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetSessionStateResponse", len)?; + if self.agent_state != 0 { + let v = AgentState::try_from(self.agent_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.agent_state)))?; + struct_ser.serialize_field("agentState", &v)?; + } + if self.user_state != 0 { + let v = UserState::try_from(self.user_state) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.user_state)))?; + struct_ser.serialize_field("userState", &v)?; + } + if !self.agent_id.is_empty() { + struct_ser.serialize_field("agentId", &self.agent_id)?; + } + if !self.options.is_empty() { + struct_ser.serialize_field("options", &self.options)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetSessionStateResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "agent_state", + "agentState", + "user_state", + "userState", + "agent_id", + "agentId", + "options", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AgentState, + UserState, + AgentId, + Options, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "agentState" | "agent_state" => Ok(GeneratedField::AgentState), + "userState" | "user_state" => Ok(GeneratedField::UserState), + "agentId" | "agent_id" => Ok(GeneratedField::AgentId), + "options" => Ok(GeneratedField::Options), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetSessionStateResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetSessionStateResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut agent_state__ = None; + let mut user_state__ = None; + let mut agent_id__ = None; + let mut options__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AgentState => { + if agent_state__.is_some() { + return Err(serde::de::Error::duplicate_field("agentState")); + } + agent_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::UserState => { + if user_state__.is_some() { + return Err(serde::de::Error::duplicate_field("userState")); + } + user_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::AgentId => { + if agent_id__.is_some() { + return Err(serde::de::Error::duplicate_field("agentId")); + } + agent_id__ = Some(map_.next_value()?); + } + GeneratedField::Options => { + if options__.is_some() { + return Err(serde::de::Error::duplicate_field("options")); + } + options__ = Some( + map_.next_value::>()? + ); + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetSessionStateResponse { + agent_state: agent_state__.unwrap_or_default(), + user_state: user_state__.unwrap_or_default(), + agent_id: agent_id__.unwrap_or_default(), + options: options__.unwrap_or_default(), + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetSessionStateResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::GetSessionUsageResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.usage.is_some() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.GetSessionUsageResponse", len)?; + if let Some(v) = self.usage.as_ref() { + struct_ser.serialize_field("usage", v)?; + } + if let Some(v) = self.created_at.as_ref() { + struct_ser.serialize_field("createdAt", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::GetSessionUsageResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "usage", + "created_at", + "createdAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Usage, + CreatedAt, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "usage" => Ok(GeneratedField::Usage), + "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::GetSessionUsageResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.GetSessionUsageResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut usage__ = None; + let mut created_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Usage => { + if usage__.is_some() { + return Err(serde::de::Error::duplicate_field("usage")); + } + usage__ = map_.next_value()?; + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + created_at__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::GetSessionUsageResponse { + usage: usage__, + created_at: created_at__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.GetSessionUsageResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::Pong { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.Pong", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::Pong { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::Pong; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.Pong") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_response::Pong { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.Pong", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::RunInputResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.items.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.RunInputResponse", len)?; + if !self.items.is_empty() { + struct_ser.serialize_field("items", &self.items)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::RunInputResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "items", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Items, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "items" => Ok(GeneratedField::Items), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::RunInputResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.RunInputResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut items__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Items => { + if items__.is_some() { + return Err(serde::de::Error::duplicate_field("items")); + } + items__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(session_response::RunInputResponse { + items: items__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.RunInputResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for session_response::UpdateIoResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.agent.SessionResponse.UpdateIOResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for session_response::UpdateIoResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = session_response::UpdateIoResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionResponse.UpdateIOResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(session_response::UpdateIoResponse { + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionResponse.UpdateIOResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SessionSettings { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.sample_rate != 0 { + len += 1; + } + if self.encoding != 0 { + len += 1; + } + if self.type_settings.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.SessionSettings", len)?; + if self.sample_rate != 0 { + struct_ser.serialize_field("sampleRate", &self.sample_rate)?; + } + if self.encoding != 0 { + let v = AudioEncoding::try_from(self.encoding) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encoding)))?; + struct_ser.serialize_field("encoding", &v)?; + } + if let Some(v) = self.type_settings.as_ref() { + match v { + session_settings::TypeSettings::EotSettings(v) => { + struct_ser.serialize_field("eotSettings", v)?; + } + session_settings::TypeSettings::InterruptionSettings(v) => { + struct_ser.serialize_field("interruptionSettings", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SessionSettings { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sample_rate", + "sampleRate", + "encoding", + "eot_settings", + "eotSettings", + "interruption_settings", + "interruptionSettings", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SampleRate, + Encoding, + EotSettings, + InterruptionSettings, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sampleRate" | "sample_rate" => Ok(GeneratedField::SampleRate), + "encoding" => Ok(GeneratedField::Encoding), + "eotSettings" | "eot_settings" => Ok(GeneratedField::EotSettings), + "interruptionSettings" | "interruption_settings" => Ok(GeneratedField::InterruptionSettings), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SessionSettings; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.SessionSettings") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sample_rate__ = None; + let mut encoding__ = None; + let mut type_settings__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SampleRate => { + if sample_rate__.is_some() { + return Err(serde::de::Error::duplicate_field("sampleRate")); + } + sample_rate__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Encoding => { + if encoding__.is_some() { + return Err(serde::de::Error::duplicate_field("encoding")); + } + encoding__ = Some(map_.next_value::()? as i32); + } + GeneratedField::EotSettings => { + if type_settings__.is_some() { + return Err(serde::de::Error::duplicate_field("eotSettings")); + } + type_settings__ = map_.next_value::<::std::option::Option<_>>()?.map(session_settings::TypeSettings::EotSettings) +; + } + GeneratedField::InterruptionSettings => { + if type_settings__.is_some() { + return Err(serde::de::Error::duplicate_field("interruptionSettings")); + } + type_settings__ = map_.next_value::<::std::option::Option<_>>()?.map(session_settings::TypeSettings::InterruptionSettings) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SessionSettings { + sample_rate: sample_rate__.unwrap_or_default(), + encoding: encoding__.unwrap_or_default(), + type_settings: type_settings__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.SessionSettings", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TtsModelUsage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.provider.is_empty() { + len += 1; + } + if !self.model.is_empty() { + len += 1; + } + if self.input_tokens != 0 { + len += 1; + } + if self.output_tokens != 0 { + len += 1; + } + if self.characters_count != 0 { + len += 1; + } + if self.audio_duration != 0. { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TTSModelUsage", len)?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; + } + if !self.model.is_empty() { + struct_ser.serialize_field("model", &self.model)?; + } + if self.input_tokens != 0 { + struct_ser.serialize_field("inputTokens", &self.input_tokens)?; + } + if self.output_tokens != 0 { + struct_ser.serialize_field("outputTokens", &self.output_tokens)?; + } + if self.characters_count != 0 { + struct_ser.serialize_field("charactersCount", &self.characters_count)?; + } + if self.audio_duration != 0. { + struct_ser.serialize_field("audioDuration", &self.audio_duration)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TtsModelUsage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "provider", + "model", + "input_tokens", + "inputTokens", + "output_tokens", + "outputTokens", + "characters_count", + "charactersCount", + "audio_duration", + "audioDuration", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Provider, + Model, + InputTokens, + OutputTokens, + CharactersCount, + AudioDuration, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "provider" => Ok(GeneratedField::Provider), + "model" => Ok(GeneratedField::Model), + "inputTokens" | "input_tokens" => Ok(GeneratedField::InputTokens), + "outputTokens" | "output_tokens" => Ok(GeneratedField::OutputTokens), + "charactersCount" | "characters_count" => Ok(GeneratedField::CharactersCount), + "audioDuration" | "audio_duration" => Ok(GeneratedField::AudioDuration), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TtsModelUsage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TTSModelUsage") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut provider__ = None; + let mut model__ = None; + let mut input_tokens__ = None; + let mut output_tokens__ = None; + let mut characters_count__ = None; + let mut audio_duration__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); + } + GeneratedField::Model => { + if model__.is_some() { + return Err(serde::de::Error::duplicate_field("model")); + } + model__ = Some(map_.next_value()?); + } + GeneratedField::InputTokens => { + if input_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("inputTokens")); + } + input_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputTokens => { + if output_tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("outputTokens")); + } + output_tokens__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::CharactersCount => { + if characters_count__.is_some() { + return Err(serde::de::Error::duplicate_field("charactersCount")); + } + characters_count__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::AudioDuration => { + if audio_duration__.is_some() { + return Err(serde::de::Error::duplicate_field("audioDuration")); + } + audio_duration__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TtsModelUsage { + provider: provider__.unwrap_or_default(), + model: model__.unwrap_or_default(), + input_tokens: input_tokens__.unwrap_or_default(), + output_tokens: output_tokens__.unwrap_or_default(), + characters_count: characters_count__.unwrap_or_default(), + audio_duration: audio_duration__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.TTSModelUsage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageComplete { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.result.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TextMessageComplete", len)?; + if let Some(v) = self.result.as_ref() { + match v { + text_message_complete::Result::SessionState(v) => { + struct_ser.serialize_field("sessionState", v)?; + } + text_message_complete::Result::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageComplete { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "session_state", + "sessionState", + "error", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SessionState, + Error, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sessionState" | "session_state" => Ok(GeneratedField::SessionState), + "error" => Ok(GeneratedField::Error), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageComplete; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TextMessageComplete") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut result__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SessionState => { + if result__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionState")); + } + result__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_complete::Result::SessionState) +; + } + GeneratedField::Error => { + if result__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + result__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_complete::Result::Error) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageComplete { + result: result__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.TextMessageComplete", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageError { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + if self.code != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TextMessageError", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + if self.code != 0 { + let v = TextMessageErrorCode::try_from(self.code) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.code)))?; + struct_ser.serialize_field("code", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageError { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + "code", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + Code, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "message" => Ok(GeneratedField::Message), + "code" => Ok(GeneratedField::Code), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageError; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TextMessageError") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + let mut code__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + GeneratedField::Code => { + if code__.is_some() { + return Err(serde::de::Error::duplicate_field("code")); + } + code__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageError { + message: message__.unwrap_or_default(), + code: code__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.agent.TextMessageError", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageErrorCode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::InternalError => "INTERNAL_ERROR", + Self::SessionStateNotFound => "SESSION_STATE_NOT_FOUND", + Self::TextHandlerError => "TEXT_HANDLER_ERROR", + Self::ProcessClosed => "PROCESS_CLOSED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for TextMessageErrorCode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "INTERNAL_ERROR", + "SESSION_STATE_NOT_FOUND", + "TEXT_HANDLER_ERROR", + "PROCESS_CLOSED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageErrorCode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "INTERNAL_ERROR" => Ok(TextMessageErrorCode::InternalError), + "SESSION_STATE_NOT_FOUND" => Ok(TextMessageErrorCode::SessionStateNotFound), + "TEXT_HANDLER_ERROR" => Ok(TextMessageErrorCode::TextHandlerError), + "PROCESS_CLOSED" => Ok(TextMessageErrorCode::ProcessClosed), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.text.is_empty() { + len += 1; + } + if !self.message_id.is_empty() { + len += 1; + } + if !self.session_id.is_empty() { + len += 1; + } + if !self.agent_name.is_empty() { + len += 1; + } + if !self.metadata.is_empty() { + len += 1; + } + if self.session_state.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TextMessageRequest", len)?; + if !self.text.is_empty() { + struct_ser.serialize_field("text", &self.text)?; + } + if !self.message_id.is_empty() { + struct_ser.serialize_field("messageId", &self.message_id)?; + } + if !self.session_id.is_empty() { + struct_ser.serialize_field("sessionId", &self.session_id)?; + } + if !self.agent_name.is_empty() { + struct_ser.serialize_field("agentName", &self.agent_name)?; + } + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; + } + if let Some(v) = self.session_state.as_ref() { + struct_ser.serialize_field("sessionState", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "text", + "message_id", + "messageId", + "session_id", + "sessionId", + "agent_name", + "agentName", + "metadata", + "session_state", + "sessionState", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Text, + MessageId, + SessionId, + AgentName, + Metadata, + SessionState, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "text" => Ok(GeneratedField::Text), + "messageId" | "message_id" => Ok(GeneratedField::MessageId), + "sessionId" | "session_id" => Ok(GeneratedField::SessionId), + "agentName" | "agent_name" => Ok(GeneratedField::AgentName), + "metadata" => Ok(GeneratedField::Metadata), + "sessionState" | "session_state" => Ok(GeneratedField::SessionState), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TextMessageRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut text__ = None; + let mut message_id__ = None; + let mut session_id__ = None; + let mut agent_name__ = None; + let mut metadata__ = None; + let mut session_state__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Text => { + if text__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + text__ = Some(map_.next_value()?); + } + GeneratedField::MessageId => { + if message_id__.is_some() { + return Err(serde::de::Error::duplicate_field("messageId")); + } + message_id__ = Some(map_.next_value()?); + } + GeneratedField::SessionId => { + if session_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionId")); + } + session_id__ = Some(map_.next_value()?); + } + GeneratedField::AgentName => { + if agent_name__.is_some() { + return Err(serde::de::Error::duplicate_field("agentName")); + } + agent_name__ = Some(map_.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some(map_.next_value()?); + } + GeneratedField::SessionState => { + if session_state__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionState")); + } + session_state__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageRequest { + text: text__.unwrap_or_default(), + message_id: message_id__.unwrap_or_default(), + session_id: session_id__.unwrap_or_default(), + agent_name: agent_name__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + session_state: session_state__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.TextMessageRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message_id.is_empty() { + len += 1; + } + if !self.session_id.is_empty() { + len += 1; + } + if self.event.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TextMessageResponse", len)?; + if !self.message_id.is_empty() { + struct_ser.serialize_field("messageId", &self.message_id)?; + } + if !self.session_id.is_empty() { + struct_ser.serialize_field("sessionId", &self.session_id)?; + } + if let Some(v) = self.event.as_ref() { + match v { + text_message_response::Event::Message(v) => { + struct_ser.serialize_field("message", v)?; + } + text_message_response::Event::FunctionCall(v) => { + struct_ser.serialize_field("functionCall", v)?; + } + text_message_response::Event::FunctionCallOutput(v) => { + struct_ser.serialize_field("functionCallOutput", v)?; + } + text_message_response::Event::AgentHandoff(v) => { + struct_ser.serialize_field("agentHandoff", v)?; + } + text_message_response::Event::Complete(v) => { + struct_ser.serialize_field("complete", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message_id", + "messageId", + "session_id", + "sessionId", + "message", + "function_call", + "functionCall", + "function_call_output", + "functionCallOutput", + "agent_handoff", + "agentHandoff", + "complete", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + MessageId, + SessionId, + Message, + FunctionCall, + FunctionCallOutput, + AgentHandoff, + Complete, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "messageId" | "message_id" => Ok(GeneratedField::MessageId), + "sessionId" | "session_id" => Ok(GeneratedField::SessionId), + "message" => Ok(GeneratedField::Message), + "functionCall" | "function_call" => Ok(GeneratedField::FunctionCall), + "functionCallOutput" | "function_call_output" => Ok(GeneratedField::FunctionCallOutput), + "agentHandoff" | "agent_handoff" => Ok(GeneratedField::AgentHandoff), + "complete" => Ok(GeneratedField::Complete), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TextMessageResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message_id__ = None; + let mut session_id__ = None; + let mut event__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::MessageId => { + if message_id__.is_some() { + return Err(serde::de::Error::duplicate_field("messageId")); + } + message_id__ = Some(map_.next_value()?); + } + GeneratedField::SessionId => { + if session_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionId")); + } + session_id__ = Some(map_.next_value()?); + } + GeneratedField::Message => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_response::Event::Message) +; + } + GeneratedField::FunctionCall => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCall")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_response::Event::FunctionCall) +; + } + GeneratedField::FunctionCallOutput => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("functionCallOutput")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_response::Event::FunctionCallOutput) +; + } + GeneratedField::AgentHandoff => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("agentHandoff")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_response::Event::AgentHandoff) +; + } + GeneratedField::Complete => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("complete")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(text_message_response::Event::Complete) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageResponse { + message_id: message_id__.unwrap_or_default(), + session_id: session_id__.unwrap_or_default(), + event: event__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.TextMessageResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TimedString { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.text.is_empty() { + len += 1; + } + if self.start_time.is_some() { + len += 1; + } + if self.end_time.is_some() { + len += 1; + } + if self.confidence.is_some() { + len += 1; + } + if self.start_time_offset.is_some() { + len += 1; + } + if self.speaker_id.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.agent.TimedString", len)?; + if !self.text.is_empty() { + struct_ser.serialize_field("text", &self.text)?; + } + if let Some(v) = self.start_time.as_ref() { + struct_ser.serialize_field("startTime", v)?; + } + if let Some(v) = self.end_time.as_ref() { + struct_ser.serialize_field("endTime", v)?; + } + if let Some(v) = self.confidence.as_ref() { + struct_ser.serialize_field("confidence", v)?; + } + if let Some(v) = self.start_time_offset.as_ref() { + struct_ser.serialize_field("startTimeOffset", v)?; + } + if let Some(v) = self.speaker_id.as_ref() { + struct_ser.serialize_field("speakerId", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TimedString { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "text", + "start_time", + "startTime", + "end_time", + "endTime", + "confidence", + "start_time_offset", + "startTimeOffset", + "speaker_id", + "speakerId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Text, + StartTime, + EndTime, + Confidence, + StartTimeOffset, + SpeakerId, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "text" => Ok(GeneratedField::Text), + "startTime" | "start_time" => Ok(GeneratedField::StartTime), + "endTime" | "end_time" => Ok(GeneratedField::EndTime), + "confidence" => Ok(GeneratedField::Confidence), + "startTimeOffset" | "start_time_offset" => Ok(GeneratedField::StartTimeOffset), + "speakerId" | "speaker_id" => Ok(GeneratedField::SpeakerId), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TimedString; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.agent.TimedString") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut text__ = None; + let mut start_time__ = None; + let mut end_time__ = None; + let mut confidence__ = None; + let mut start_time_offset__ = None; + let mut speaker_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Text => { + if text__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + text__ = Some(map_.next_value()?); + } + GeneratedField::StartTime => { + if start_time__.is_some() { + return Err(serde::de::Error::duplicate_field("startTime")); + } + start_time__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::EndTime => { + if end_time__.is_some() { + return Err(serde::de::Error::duplicate_field("endTime")); + } + end_time__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Confidence => { + if confidence__.is_some() { + return Err(serde::de::Error::duplicate_field("confidence")); + } + confidence__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::StartTimeOffset => { + if start_time_offset__.is_some() { + return Err(serde::de::Error::duplicate_field("startTimeOffset")); + } + start_time_offset__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::SpeakerId => { + if speaker_id__.is_some() { + return Err(serde::de::Error::duplicate_field("speakerId")); + } + speaker_id__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TimedString { + text: text__.unwrap_or_default(), + start_time: start_time__, + end_time: end_time__, + confidence: confidence__, + start_time_offset: start_time_offset__, + speaker_id: speaker_id__, + }) + } + } + deserializer.deserialize_struct("livekit.agent.TimedString", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ToolCallStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::TcRunning => "TC_RUNNING", + Self::TcDone => "TC_DONE", + Self::TcError => "TC_ERROR", + Self::TcCancelled => "TC_CANCELLED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ToolCallStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "TC_RUNNING", + "TC_DONE", + "TC_ERROR", + "TC_CANCELLED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ToolCallStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "TC_RUNNING" => Ok(ToolCallStatus::TcRunning), + "TC_DONE" => Ok(ToolCallStatus::TcDone), + "TC_ERROR" => Ok(ToolCallStatus::TcError), + "TC_CANCELLED" => Ok(ToolCallStatus::TcCancelled), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ToolReplyStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::TrScheduled => "TR_SCHEDULED", + Self::TrCompleted => "TR_COMPLETED", + Self::TrInterrupted => "TR_INTERRUPTED", + Self::TrSkipped => "TR_SKIPPED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ToolReplyStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "TR_SCHEDULED", + "TR_COMPLETED", + "TR_INTERRUPTED", + "TR_SKIPPED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ToolReplyStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "TR_SCHEDULED" => Ok(ToolReplyStatus::TrScheduled), + "TR_COMPLETED" => Ok(ToolReplyStatus::TrCompleted), + "TR_INTERRUPTED" => Ok(ToolReplyStatus::TrInterrupted), + "TR_SKIPPED" => Ok(ToolReplyStatus::TrSkipped), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for UserState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::UsSpeaking => "US_SPEAKING", + Self::UsListening => "US_LISTENING", + Self::UsAway => "US_AWAY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for UserState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "US_SPEAKING", + "US_LISTENING", + "US_AWAY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UserState; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "US_SPEAKING" => Ok(UserState::UsSpeaking), + "US_LISTENING" => Ok(UserState::UsListening), + "US_AWAY" => Ok(UserState::UsAway), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} diff --git a/livekit-protocol/src/livekit.rs b/livekit-protocol/src/livekit.rs index 58d025be7..e0acd6917 100644 --- a/livekit-protocol/src/livekit.rs +++ b/livekit-protocol/src/livekit.rs @@ -94,14 +94,6 @@ pub struct MetricsRecordingHeader { pub room_name: ::prost::alloc::string::String, #[prost(message, optional, tag="7")] pub room_start_time: ::core::option::Option<::pbjson_types::Timestamp>, - #[prost(string, tag="8")] - pub job_id: ::prost::alloc::string::String, - /// session is a simulation; the collector skips PII redaction for it unless redaction_enabled is set - #[prost(bool, tag="9")] - pub simulated: bool, - /// force PII redaction on for this session (only ever enables, never disables) - #[prost(bool, tag="10")] - pub redaction_enabled: bool, } // // Protocol used to record metrics for a specific session. @@ -479,9 +471,8 @@ pub mod participant_info { Forwarded = 1, ConnectorWhatsapp = 2, ConnectorTwilio = 3, + /// NEXT_ID: 5 BridgeRtsp = 4, - /// NEXT_ID: 6 - Simulation = 5, } impl KindDetail { /// String value of the enum field names used in the ProtoBuf definition. @@ -495,7 +486,6 @@ pub mod participant_info { KindDetail::ConnectorWhatsapp => "CONNECTOR_WHATSAPP", KindDetail::ConnectorTwilio => "CONNECTOR_TWILIO", KindDetail::BridgeRtsp => "BRIDGE_RTSP", - KindDetail::Simulation => "SIMULATION", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -506,7 +496,6 @@ pub mod participant_info { "CONNECTOR_WHATSAPP" => Some(Self::ConnectorWhatsapp), "CONNECTOR_TWILIO" => Some(Self::ConnectorTwilio), "BRIDGE_RTSP" => Some(Self::BridgeRtsp), - "SIMULATION" => Some(Self::Simulation), _ => None, } } @@ -4922,8 +4911,6 @@ pub struct Job { pub deployment: ::prost::alloc::string::String, #[prost(map="string, string", tag="12")] pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, - #[prost(bool, tag="13")] - pub enable_redaction: bool, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -7699,9 +7686,6 @@ pub struct ConnectWhatsAppCallRequest { /// It is the answer SDP for a business initiated call #[prost(message, optional, tag="2")] pub sdp: ::core::option::Option, - /// Wait for the answer for the call before returning. - #[prost(bool, tag="3")] - pub wait_until_answered: bool, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] diff --git a/livekit-protocol/src/livekit.serde.rs b/livekit-protocol/src/livekit.serde.rs index abe5e4b82..835d3052d 100644 --- a/livekit-protocol/src/livekit.serde.rs +++ b/livekit-protocol/src/livekit.serde.rs @@ -7725,9 +7725,6 @@ impl serde::Serialize for ConnectWhatsAppCallRequest { if self.sdp.is_some() { len += 1; } - if self.wait_until_answered { - len += 1; - } let mut struct_ser = serializer.serialize_struct("livekit.ConnectWhatsAppCallRequest", len)?; if !self.whatsapp_call_id.is_empty() { struct_ser.serialize_field("whatsappCallId", &self.whatsapp_call_id)?; @@ -7735,9 +7732,6 @@ impl serde::Serialize for ConnectWhatsAppCallRequest { if let Some(v) = self.sdp.as_ref() { struct_ser.serialize_field("sdp", v)?; } - if self.wait_until_answered { - struct_ser.serialize_field("waitUntilAnswered", &self.wait_until_answered)?; - } struct_ser.end() } } @@ -7751,15 +7745,12 @@ impl<'de> serde::Deserialize<'de> for ConnectWhatsAppCallRequest { "whatsapp_call_id", "whatsappCallId", "sdp", - "wait_until_answered", - "waitUntilAnswered", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { WhatsappCallId, Sdp, - WaitUntilAnswered, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -7784,7 +7775,6 @@ impl<'de> serde::Deserialize<'de> for ConnectWhatsAppCallRequest { match value { "whatsappCallId" | "whatsapp_call_id" => Ok(GeneratedField::WhatsappCallId), "sdp" => Ok(GeneratedField::Sdp), - "waitUntilAnswered" | "wait_until_answered" => Ok(GeneratedField::WaitUntilAnswered), _ => Ok(GeneratedField::__SkipField__), } } @@ -7806,7 +7796,6 @@ impl<'de> serde::Deserialize<'de> for ConnectWhatsAppCallRequest { { let mut whatsapp_call_id__ = None; let mut sdp__ = None; - let mut wait_until_answered__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::WhatsappCallId => { @@ -7821,12 +7810,6 @@ impl<'de> serde::Deserialize<'de> for ConnectWhatsAppCallRequest { } sdp__ = map_.next_value()?; } - GeneratedField::WaitUntilAnswered => { - if wait_until_answered__.is_some() { - return Err(serde::de::Error::duplicate_field("waitUntilAnswered")); - } - wait_until_answered__ = Some(map_.next_value()?); - } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -7835,7 +7818,6 @@ impl<'de> serde::Deserialize<'de> for ConnectWhatsAppCallRequest { Ok(ConnectWhatsAppCallRequest { whatsapp_call_id: whatsapp_call_id__.unwrap_or_default(), sdp: sdp__, - wait_until_answered: wait_until_answered__.unwrap_or_default(), }) } } @@ -22563,9 +22545,6 @@ impl serde::Serialize for Job { if !self.attributes.is_empty() { len += 1; } - if self.enable_redaction { - len += 1; - } let mut struct_ser = serializer.serialize_struct("livekit.Job", len)?; if !self.id.is_empty() { struct_ser.serialize_field("id", &self.id)?; @@ -22605,9 +22584,6 @@ impl serde::Serialize for Job { if !self.attributes.is_empty() { struct_ser.serialize_field("attributes", &self.attributes)?; } - if self.enable_redaction { - struct_ser.serialize_field("enableRedaction", &self.enable_redaction)?; - } struct_ser.end() } } @@ -22633,8 +22609,6 @@ impl<'de> serde::Deserialize<'de> for Job { "enableRecording", "deployment", "attributes", - "enable_redaction", - "enableRedaction", ]; #[allow(clippy::enum_variant_names)] @@ -22651,7 +22625,6 @@ impl<'de> serde::Deserialize<'de> for Job { EnableRecording, Deployment, Attributes, - EnableRedaction, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -22686,7 +22659,6 @@ impl<'de> serde::Deserialize<'de> for Job { "enableRecording" | "enable_recording" => Ok(GeneratedField::EnableRecording), "deployment" => Ok(GeneratedField::Deployment), "attributes" => Ok(GeneratedField::Attributes), - "enableRedaction" | "enable_redaction" => Ok(GeneratedField::EnableRedaction), _ => Ok(GeneratedField::__SkipField__), } } @@ -22718,7 +22690,6 @@ impl<'de> serde::Deserialize<'de> for Job { let mut enable_recording__ = None; let mut deployment__ = None; let mut attributes__ = None; - let mut enable_redaction__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Id => { @@ -22795,12 +22766,6 @@ impl<'de> serde::Deserialize<'de> for Job { map_.next_value::>()? ); } - GeneratedField::EnableRedaction => { - if enable_redaction__.is_some() { - return Err(serde::de::Error::duplicate_field("enableRedaction")); - } - enable_redaction__ = Some(map_.next_value()?); - } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -22819,7 +22784,6 @@ impl<'de> serde::Deserialize<'de> for Job { enable_recording: enable_recording__.unwrap_or_default(), deployment: deployment__.unwrap_or_default(), attributes: attributes__.unwrap_or_default(), - enable_redaction: enable_redaction__.unwrap_or_default(), }) } } @@ -27165,15 +27129,6 @@ impl serde::Serialize for MetricsRecordingHeader { if self.room_start_time.is_some() { len += 1; } - if !self.job_id.is_empty() { - len += 1; - } - if self.simulated { - len += 1; - } - if self.redaction_enabled { - len += 1; - } let mut struct_ser = serializer.serialize_struct("livekit.MetricsRecordingHeader", len)?; if !self.room_id.is_empty() { struct_ser.serialize_field("roomId", &self.room_id)?; @@ -27195,15 +27150,6 @@ impl serde::Serialize for MetricsRecordingHeader { if let Some(v) = self.room_start_time.as_ref() { struct_ser.serialize_field("roomStartTime", v)?; } - if !self.job_id.is_empty() { - struct_ser.serialize_field("jobId", &self.job_id)?; - } - if self.simulated { - struct_ser.serialize_field("simulated", &self.simulated)?; - } - if self.redaction_enabled { - struct_ser.serialize_field("redactionEnabled", &self.redaction_enabled)?; - } struct_ser.end() } } @@ -27225,11 +27171,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { "roomName", "room_start_time", "roomStartTime", - "job_id", - "jobId", - "simulated", - "redaction_enabled", - "redactionEnabled", ]; #[allow(clippy::enum_variant_names)] @@ -27240,9 +27181,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { RoomTags, RoomName, RoomStartTime, - JobId, - Simulated, - RedactionEnabled, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -27271,9 +27209,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { "roomTags" | "room_tags" => Ok(GeneratedField::RoomTags), "roomName" | "room_name" => Ok(GeneratedField::RoomName), "roomStartTime" | "room_start_time" => Ok(GeneratedField::RoomStartTime), - "jobId" | "job_id" => Ok(GeneratedField::JobId), - "simulated" => Ok(GeneratedField::Simulated), - "redactionEnabled" | "redaction_enabled" => Ok(GeneratedField::RedactionEnabled), _ => Ok(GeneratedField::__SkipField__), } } @@ -27299,9 +27234,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { let mut room_tags__ = None; let mut room_name__ = None; let mut room_start_time__ = None; - let mut job_id__ = None; - let mut simulated__ = None; - let mut redaction_enabled__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::RoomId => { @@ -27344,24 +27276,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { } room_start_time__ = map_.next_value()?; } - GeneratedField::JobId => { - if job_id__.is_some() { - return Err(serde::de::Error::duplicate_field("jobId")); - } - job_id__ = Some(map_.next_value()?); - } - GeneratedField::Simulated => { - if simulated__.is_some() { - return Err(serde::de::Error::duplicate_field("simulated")); - } - simulated__ = Some(map_.next_value()?); - } - GeneratedField::RedactionEnabled => { - if redaction_enabled__.is_some() { - return Err(serde::de::Error::duplicate_field("redactionEnabled")); - } - redaction_enabled__ = Some(map_.next_value()?); - } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -27374,9 +27288,6 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { room_tags: room_tags__.unwrap_or_default(), room_name: room_name__.unwrap_or_default(), room_start_time: room_start_time__, - job_id: job_id__.unwrap_or_default(), - simulated: simulated__.unwrap_or_default(), - redaction_enabled: redaction_enabled__.unwrap_or_default(), }) } } @@ -29170,7 +29081,6 @@ impl serde::Serialize for participant_info::KindDetail { Self::ConnectorWhatsapp => "CONNECTOR_WHATSAPP", Self::ConnectorTwilio => "CONNECTOR_TWILIO", Self::BridgeRtsp => "BRIDGE_RTSP", - Self::Simulation => "SIMULATION", }; serializer.serialize_str(variant) } @@ -29187,7 +29097,6 @@ impl<'de> serde::Deserialize<'de> for participant_info::KindDetail { "CONNECTOR_WHATSAPP", "CONNECTOR_TWILIO", "BRIDGE_RTSP", - "SIMULATION", ]; struct GeneratedVisitor; @@ -29233,7 +29142,6 @@ impl<'de> serde::Deserialize<'de> for participant_info::KindDetail { "CONNECTOR_WHATSAPP" => Ok(participant_info::KindDetail::ConnectorWhatsapp), "CONNECTOR_TWILIO" => Ok(participant_info::KindDetail::ConnectorTwilio), "BRIDGE_RTSP" => Ok(participant_info::KindDetail::BridgeRtsp), - "SIMULATION" => Ok(participant_info::KindDetail::Simulation), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } }