// This file is @generated by prost-build.#![allow(clippy::trivially_copy_pass_by_ref)]#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]pub struct LoadThreadConfigRequest {    #[prost(string, optional, tag = "1")]    pub thread_id: ::core::option::Option<::prost::alloc::string::String>,    #[prost(string, optional, tag = "2")]    pub cwd: ::core::option::Option<::prost::alloc::string::String>,}#[derive(Clone, PartialEq, ::prost::Message)]pub struct LoadThreadConfigResponse {    #[prost(message, repeated, tag = "1")]    pub sources: ::prost::alloc::vec::Vec<ThreadConfigSource>,}#[derive(Clone, PartialEq, ::prost::Message)]pub struct ThreadConfigSource {    #[prost(oneof = "thread_config_source::Source", tags = "1, 2")]    pub source: ::core::option::Option<thread_config_source::Source>,}/// Nested message and enum types in `ThreadConfigSource`.pub mod thread_config_source {    #[derive(Clone, PartialEq, ::prost::Oneof)]    pub enum Source {        #[prost(message, tag = "1")]        Session(super::SessionThreadConfig),        #[prost(message, tag = "2")]        User(super::UserThreadConfig),    }}#[derive(Clone, PartialEq, ::prost::Message)]pub struct SessionThreadConfig {    #[prost(string, optional, tag = "1")]    pub model_provider: ::core::option::Option<::prost::alloc::string::String>,    #[prost(message, repeated, tag = "2")]    pub model_providers: ::prost::alloc::vec::Vec<ModelProvider>,    #[prost(map = "string, bool", tag = "3")]    pub features: ::std::collections::HashMap<::prost::alloc::string::String, bool>,}#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]pub struct UserThreadConfig {}#[derive(Clone, PartialEq, ::prost::Message)]pub struct ModelProvider {    #[prost(string, tag = "1")]    pub id: ::prost::alloc::string::String,    #[prost(string, tag = "2")]    pub name: ::prost::alloc::string::String,    #[prost(string, optional, tag = "3")]    pub base_url: ::core::option::Option<::prost::alloc::string::String>,    #[prost(string, optional, tag = "4")]    pub env_key: ::core::option::Option<::prost::alloc::string::String>,    #[prost(string, optional, tag = "5")]    pub env_key_instructions: ::core::option::Option<::prost::alloc::string::String>,    #[prost(string, optional, tag = "6")]    pub experimental_bearer_token: ::core::option::Option<::prost::alloc::string::String>,    #[prost(message, optional, tag = "7")]    pub auth: ::core::option::Option<ModelProviderAuthInfo>,    #[prost(enumeration = "WireApi", tag = "8")]    pub wire_api: i32,    #[prost(message, optional, tag = "9")]    pub query_params: ::core::option::Option<StringMap>,    #[prost(message, optional, tag = "10")]    pub http_headers: ::core::option::Option<StringMap>,    #[prost(message, optional, tag = "11")]    pub env_http_headers: ::core::option::Option<StringMap>,    #[prost(uint64, optional, tag = "12")]    pub request_max_retries: ::core::option::Option<u64>,    #[prost(uint64, optional, tag = "13")]    pub stream_max_retries: ::core::option::Option<u64>,    #[prost(uint64, optional, tag = "14")]    pub stream_idle_timeout_ms: ::core::option::Option<u64>,    #[prost(uint64, optional, tag = "15")]    pub websocket_connect_timeout_ms: ::core::option::Option<u64>,    #[prost(bool, tag = "16")]    pub requires_openai_auth: bool,    #[prost(bool, tag = "17")]    pub supports_websockets: bool,}#[derive(Clone, PartialEq, ::prost::Message)]pub struct StringMap {    #[prost(map = "string, string", tag = "1")]    pub values:        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,}#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]pub struct ModelProviderAuthInfo {    #[prost(string, tag = "1")]    pub command: ::prost::alloc::string::String,    #[prost(string, repeated, tag = "2")]    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,    #[prost(uint64, tag = "3")]    pub timeout_ms: u64,    #[prost(uint64, tag = "4")]    pub refresh_interval_ms: u64,    #[prost(string, tag = "5")]    pub cwd: ::prost::alloc::string::String,}#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]#[repr(i32)]pub enum WireApi {    Unspecified = 0,    Responses = 1,}impl WireApi {    /// 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 {            Self::Unspecified => "WIRE_API_UNSPECIFIED",            Self::Responses => "WIRE_API_RESPONSES",        }    }    /// Creates an enum from field names used in the ProtoBuf definition.    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {        match value {            "WIRE_API_UNSPECIFIED" => Some(Self::Unspecified),            "WIRE_API_RESPONSES" => Some(Self::Responses),            _ => None,        }    }}/// Generated client implementations.pub mod thread_config_loader_client {    #![allow(        unused_variables,        dead_code,        missing_docs,        clippy::wildcard_imports,        clippy::let_unit_value    )]    use tonic::codegen::http::Uri;    use tonic::codegen::*;    #[derive(Debug, Clone)]    pub struct ThreadConfigLoaderClient<T> {        inner: tonic::client::Grpc<T>,    }    impl ThreadConfigLoaderClient<tonic::transport::Channel> {        /// Attempt to create a new client by connecting to a given endpoint.        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>        where            D: TryInto<tonic::transport::Endpoint>,            D::Error: Into<StdError>,        {            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;            Ok(Self::new(conn))        }    }    impl<T> ThreadConfigLoaderClient<T>    where        T: tonic::client::GrpcService<tonic::body::Body>,        T::Error: Into<StdError>,        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,    {        pub fn new(inner: T) -> Self {            let inner = tonic::client::Grpc::new(inner);            Self { inner }        }        pub fn with_origin(inner: T, origin: Uri) -> Self {            let inner = tonic::client::Grpc::with_origin(inner, origin);            Self { inner }        }        pub fn with_interceptor<F>(            inner: T,            interceptor: F,        ) -> ThreadConfigLoaderClient<InterceptedService<T, F>>        where            F: tonic::service::Interceptor,            T::ResponseBody: Default,            T: tonic::codegen::Service<                    http::Request<tonic::body::Body>,                    Response = http::Response<                        <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,                    >,                >,            <T as tonic::codegen::Service<http::Request<tonic::body::Body>>>::Error:                Into<StdError> + std::marker::Send + std::marker::Sync,        {            ThreadConfigLoaderClient::new(InterceptedService::new(inner, interceptor))        }        /// Compress requests with the given encoding.        ///        /// This requires the server to support it otherwise it might respond with an        /// error.        #[must_use]        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {            self.inner = self.inner.send_compressed(encoding);            self        }        /// Enable decompressing responses.        #[must_use]        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {            self.inner = self.inner.accept_compressed(encoding);            self        }        /// Limits the maximum size of a decoded message.        ///        /// Default: `4MB`        #[must_use]        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {            self.inner = self.inner.max_decoding_message_size(limit);            self        }        /// Limits the maximum size of an encoded message.        ///        /// Default: `usize::MAX`        #[must_use]        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {            self.inner = self.inner.max_encoding_message_size(limit);            self        }        pub async fn load(            &mut self,            request: impl tonic::IntoRequest<super::LoadThreadConfigRequest>,        ) -> std::result::Result<tonic::Response<super::LoadThreadConfigResponse>, tonic::Status>        {            self.inner.ready().await.map_err(|e| {                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))            })?;            let codec = tonic_prost::ProstCodec::default();            let path = http::uri::PathAndQuery::from_static(                "/codex.thread_config.v1.ThreadConfigLoader/Load",            );            let mut req = request.into_request();            req.extensions_mut().insert(GrpcMethod::new(                "codex.thread_config.v1.ThreadConfigLoader",                "Load",            ));            self.inner.unary(req, path, codec).await        }    }}/// Generated server implementations.pub mod thread_config_loader_server {    #![allow(        unused_variables,        dead_code,        missing_docs,        clippy::wildcard_imports,        clippy::let_unit_value    )]    use tonic::codegen::*;    /// Generated trait containing gRPC methods that should be implemented for use with ThreadConfigLoaderServer.    #[async_trait]    pub trait ThreadConfigLoader: std::marker::Send + std::marker::Sync + 'static {        async fn load(            &self,            request: tonic::Request<super::LoadThreadConfigRequest>,        ) -> std::result::Result<tonic::Response<super::LoadThreadConfigResponse>, tonic::Status>;    }    #[derive(Debug)]    pub struct ThreadConfigLoaderServer<T> {        inner: Arc<T>,        accept_compression_encodings: EnabledCompressionEncodings,        send_compression_encodings: EnabledCompressionEncodings,        max_decoding_message_size: Option<usize>,        max_encoding_message_size: Option<usize>,    }    impl<T> ThreadConfigLoaderServer<T> {        pub fn new(inner: T) -> Self {            Self::from_arc(Arc::new(inner))        }        pub fn from_arc(inner: Arc<T>) -> Self {            Self {                inner,                accept_compression_encodings: Default::default(),                send_compression_encodings: Default::default(),                max_decoding_message_size: None,                max_encoding_message_size: None,            }        }        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>        where            F: tonic::service::Interceptor,        {            InterceptedService::new(Self::new(inner), interceptor)        }        /// Enable decompressing requests with the given encoding.        #[must_use]        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {            self.accept_compression_encodings.enable(encoding);            self        }        /// Compress responses with the given encoding, if the client supports it.        #[must_use]        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {            self.send_compression_encodings.enable(encoding);            self        }        /// Limits the maximum size of a decoded message.        ///        /// Default: `4MB`        #[must_use]        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {            self.max_decoding_message_size = Some(limit);            self        }        /// Limits the maximum size of an encoded message.        ///        /// Default: `usize::MAX`        #[must_use]        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {            self.max_encoding_message_size = Some(limit);            self        }    }    impl<T, B> tonic::codegen::Service<http::Request<B>> for ThreadConfigLoaderServer<T>    where        T: ThreadConfigLoader,        B: Body + std::marker::Send + 'static,        B::Error: Into<StdError> + std::marker::Send + 'static,    {        type Response = http::Response<tonic::body::Body>;        type Error = std::convert::Infallible;        type Future = BoxFuture<Self::Response, Self::Error>;        fn poll_ready(            &mut self,            _cx: &mut Context<'_>,        ) -> Poll<std::result::Result<(), Self::Error>> {            Poll::Ready(Ok(()))        }        fn call(&mut self, req: http::Request<B>) -> Self::Future {            match req.uri().path() {                "/codex.thread_config.v1.ThreadConfigLoader/Load" => {                    #[allow(non_camel_case_types)]                    struct LoadSvc<T: ThreadConfigLoader>(pub Arc<T>);                    impl<T: ThreadConfigLoader>                        tonic::server::UnaryService<super::LoadThreadConfigRequest> for LoadSvc<T>                    {                        type Response = super::LoadThreadConfigResponse;                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;                        fn call(                            &mut self,                            request: tonic::Request<super::LoadThreadConfigRequest>,                        ) -> Self::Future {                            let inner = Arc::clone(&self.0);                            let fut = async move {                                <T as ThreadConfigLoader>::load(&inner, request).await                            };                            Box::pin(fut)                        }                    }                    let accept_compression_encodings = self.accept_compression_encodings;                    let send_compression_encodings = self.send_compression_encodings;                    let max_decoding_message_size = self.max_decoding_message_size;                    let max_encoding_message_size = self.max_encoding_message_size;                    let inner = self.inner.clone();                    let fut = async move {                        let method = LoadSvc(inner);                        let codec = tonic_prost::ProstCodec::default();                        let mut grpc = tonic::server::Grpc::new(codec)                            .apply_compression_config(                                accept_compression_encodings,                                send_compression_encodings,                            )                            .apply_max_message_size_config(                                max_decoding_message_size,                                max_encoding_message_size,                            );                        let res = grpc.unary(method, req).await;                        Ok(res)                    };                    Box::pin(fut)                }                _ => Box::pin(async move {                    let mut response = http::Response::new(tonic::body::Body::default());                    let headers = response.headers_mut();                    headers.insert(                        tonic::Status::GRPC_STATUS,                        (tonic::Code::Unimplemented as i32).into(),                    );                    headers.insert(                        http::header::CONTENT_TYPE,                        tonic::metadata::GRPC_CONTENT_TYPE,                    );                    Ok(response)                }),            }        }    }    impl<T> Clone for ThreadConfigLoaderServer<T> {        fn clone(&self) -> Self {            let inner = self.inner.clone();            Self {                inner,                accept_compression_encodings: self.accept_compression_encodings,                send_compression_encodings: self.send_compression_encodings,                max_decoding_message_size: self.max_decoding_message_size,                max_encoding_message_size: self.max_encoding_message_size,            }        }    }    /// Generated gRPC service name    pub const SERVICE_NAME: &str = "codex.thread_config.v1.ThreadConfigLoader";    impl<T> tonic::server::NamedService for ThreadConfigLoaderServer<T> {        const NAME: &'static str = SERVICE_NAME;    }}