linger_openai_sdk/

client.rs

use crate::assistants::{
    Assistant, AssistantDeletion, AssistantListRequest, AssistantPage, CreateAssistantRequest,
    ModifyAssistantRequest,
};
use crate::audio::{
    AudioSpeechResponse, AudioTranscription, AudioTranslation, AudioVoice, AudioVoiceConsent,
    AudioVoiceConsentDeletion, AudioVoiceConsentListRequest, AudioVoiceConsentPage,
    CreateSpeechRequest, CreateTranscriptionRequest, CreateTranslationRequest,
    CreateVoiceConsentRequest, CreateVoiceRequest, UpdateVoiceConsentRequest,
};
use crate::batches::{Batch, BatchListPage, CreateBatchRequest};
use crate::chat::{
    ChatCompletion, ChatCompletionDeletion, ChatCompletionMessagePage, ChatCompletionPage,
    CreateChatCompletionRequest, ModifyChatCompletionRequest,
};
use crate::chatkit::{
    ChatKitSession, ChatKitThread, ChatKitThreadDeletion, ChatKitThreadItemPage, ChatKitThreadPage,
    CreateChatKitSessionRequest,
};
use crate::completions::{Completion, CompletionStream, CreateCompletionRequest};
use crate::config::ClientConfig;
use crate::containers::{
    Container, ContainerDeletion, ContainerFile, ContainerFileContent, ContainerFileDeletion,
    ContainerFilePage, ContainerPage, CreateContainerFileRequest, CreateContainerRequest,
};
use crate::conversations::{
    Conversation, ConversationDeletion, ConversationItem, ConversationItemDeletion,
    ConversationItemPage, CreateConversationItemRequest, CreateConversationRequest,
    ModifyConversationRequest,
};
use crate::embeddings::{CreateEmbeddingRequest, EmbeddingResponse};
use crate::error::{parse_api_error, request_id_from_headers, HeaderMap, LingerError};
use crate::evals::{
    CreateEvalRequest, CreateEvalRunRequest, Eval, EvalDeletion, EvalPage, EvalRun,
    EvalRunDeletion, EvalRunOutputItem, EvalRunOutputItemPage, EvalRunPage, ModifyEvalRequest,
};
use crate::files::{CreateFileRequest, FileContent, FileDeletion, FileObject, FilesPage};
use crate::fine_tuning::{
    CreateFineTuningCheckpointPermissionRequest, CreateFineTuningJobRequest,
    FineTuningCheckpointPage, FineTuningCheckpointPermissionDeletion,
    FineTuningCheckpointPermissionPage, FineTuningEventPage, FineTuningGraderRun,
    FineTuningGraderValidation, FineTuningJob, FineTuningJobPage, RunFineTuningGraderRequest,
    ValidateFineTuningGraderRequest,
};
use crate::images::{
    CreateImageEditRequest, CreateImageRequest, CreateImageVariationRequest, ImagesResponse,
};
use crate::models::{Model, ModelDeletion, ModelsPage};
use crate::moderations::{CreateModerationRequest, ModerationCreateResponse};
use crate::realtime::{
    CreateRealtimeCallReferRequest, CreateRealtimeCallRequest, CreateRealtimeClientSecretRequest,
    CreateRealtimeSessionRequest, CreateRealtimeTranscriptionSessionRequest,
    CreateRealtimeTranslationClientSecretRequest, RealtimeCallSdpAnswer, RealtimeClientSecret,
    RealtimeSession, RealtimeTranscriptionSession, RealtimeTranslationClientSecret,
    RejectRealtimeCallRequest,
};
use crate::responses::{
    CompactResponseRequest, CreateResponseInputTokensRequest, CreateResponseRequest, Response,
    ResponseCompaction, ResponseDeletion, ResponseInputItemsPage, ResponseInputTokens,
    ResponseStream,
};
use crate::retry::RetryDecision;
use crate::skills::{
    CreateSkillRequest, CreateSkillVersionRequest, Skill, SkillContent, SkillDeletion,
    SkillListRequest, SkillPage, SkillVersion, SkillVersionDeletion, SkillVersionListRequest,
    SkillVersionPage, UpdateSkillRequest,
};
use crate::threads::{
    CreateThreadAndRunRequest, CreateThreadMessageRequest, CreateThreadRequest,
    CreateThreadRunRequest, ModifyThreadMessageRequest, ModifyThreadRequest,
    ModifyThreadRunRequest, RunStep, RunStepListRequest, RunStepPage, RunStepRetrieveRequest,
    SubmitToolOutputsRequest, Thread, ThreadDeletion, ThreadMessage, ThreadMessageDeletion,
    ThreadMessageListRequest, ThreadMessagePage, ThreadRun, ThreadRunListRequest, ThreadRunPage,
};
use crate::transport::{HttpMethod, HttpRequest, SharedTransport};
use crate::uploads::{
    CompleteUploadRequest, CreateUploadPartRequest, CreateUploadRequest, Upload, UploadPart,
};
use crate::vector_stores::{
    CreateVectorStoreFileBatchRequest, CreateVectorStoreFileRequest, CreateVectorStoreRequest,
    CreateVectorStoreSearchRequest, ModifyVectorStoreFileRequest, ModifyVectorStoreRequest,
    VectorStore, VectorStoreDeletion, VectorStoreFile, VectorStoreFileBatch,
    VectorStoreFileContentPage, VectorStoreFileDeletion, VectorStoreFilePage, VectorStorePage,
    VectorStoreSearchPage,
};
use crate::videos::{
    CreateVideoCharacterRequest, CreateVideoEditRequest, CreateVideoExtensionRequest,
    CreateVideoRemixRequest, CreateVideoRequest, Video, VideoCharacter, VideoContent,
    VideoContentVariant, VideoDeletion, VideoPage,
};
use bytes::Bytes;

/// EN: OpenAI SDK client.
/// 中文：OpenAI SDK 客户端。
#[derive(Clone, Debug)]
pub struct Client {
    config: ClientConfig,
    transport: SharedTransport,
}

impl Client {
    /// EN: Creates a client with the default transport.
    /// 中文：使用默认传输层创建客户端。
    #[cfg(feature = "reqwest-transport")]
    pub fn new(api_key: impl Into<String>) -> Result<Self, LingerError> {
        let config = ClientConfig::builder().api_key(api_key).build()?;
        Ok(Self {
            config,
            transport: SharedTransport::new(crate::transport::ReqwestTransport::default()),
        })
    }

    /// EN: Creates a client with the provided config and default transport.
    /// 中文：使用提供的配置和默认传输层创建客户端。
    #[cfg(feature = "reqwest-transport")]
    pub fn with_config(config: ClientConfig) -> Result<Self, LingerError> {
        Ok(Self {
            config,
            transport: SharedTransport::new(crate::transport::ReqwestTransport::default()),
        })
    }

    /// EN: Creates a client from config and a custom transport.
    /// 中文：通过配置和自定义传输层创建客户端。
    pub fn with_config_and_transport(config: ClientConfig, transport: SharedTransport) -> Self {
        Self { config, transport }
    }

    /// EN: Returns the Responses API resource.
    /// 中文：返回 Responses API 资源。
    pub fn responses(&self) -> ResponsesResource {
        ResponsesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the legacy Completions API resource.
    /// 中文：返回 legacy Completions API 资源。
    pub fn completions(&self) -> CompletionsResource {
        CompletionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Conversations API resource.
    /// 中文：返回 Conversations API 资源。
    pub fn conversations(&self) -> ConversationsResource {
        ConversationsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Realtime API resource.
    /// 中文：返回 Realtime API 资源。
    pub fn realtime(&self) -> RealtimeResource {
        RealtimeResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Containers API resource.
    /// 中文：返回 Containers API 资源。
    pub fn containers(&self) -> ContainersResource {
        ContainersResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Evals API resource.
    /// 中文：返回 Evals API 资源。
    pub fn evals(&self) -> EvalsResource {
        EvalsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Models API resource.
    /// 中文：返回 Models API 资源。
    pub fn models(&self) -> ModelsResource {
        ModelsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Skills API resource.
    /// 中文：返回 Skills API 资源。
    pub fn skills(&self) -> SkillsResource {
        SkillsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Videos API resource.
    /// 中文：返回 Videos API 资源。
    pub fn videos(&self) -> VideosResource {
        VideosResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Batches API resource.
    /// 中文：返回 Batches API 资源。
    pub fn batches(&self) -> BatchesResource {
        BatchesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Files API resource.
    /// 中文：返回 Files API 资源。
    pub fn files(&self) -> FilesResource {
        FilesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Uploads API resource.
    /// 中文：返回 Uploads API 资源。
    pub fn uploads(&self) -> UploadsResource {
        UploadsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Vector Stores API resource.
    /// 中文：返回 Vector Stores API 资源。
    pub fn vector_stores(&self) -> VectorStoresResource {
        VectorStoresResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Fine-tuning API resource.
    /// 中文：返回 Fine-tuning API 资源。
    pub fn fine_tuning(&self) -> FineTuningResource {
        FineTuningResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Images API resource.
    /// 中文：返回 Images API 资源。
    pub fn images(&self) -> ImagesResource {
        ImagesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Audio API resource.
    /// 中文：返回 Audio API 资源。
    pub fn audio(&self) -> AudioResource {
        AudioResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Embeddings API resource.
    /// 中文：返回 Embeddings API 资源。
    pub fn embeddings(&self) -> EmbeddingsResource {
        EmbeddingsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Moderations API resource.
    /// 中文：返回 Moderations API 资源。
    pub fn moderations(&self) -> ModerationsResource {
        ModerationsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Chat API resource.
    /// 中文：返回 Chat API 资源。
    pub fn chat(&self) -> ChatResource {
        ChatResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the ChatKit beta API resource.
    /// 中文：返回 ChatKit beta API 资源。
    pub fn chatkit(&self) -> ChatKitResource {
        ChatKitResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Assistants API resource.
    /// 中文：返回 Assistants API 资源。
    pub fn assistants(&self) -> AssistantsResource {
        AssistantsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Threads API resource.
    /// 中文：返回 Threads API 资源。
    pub fn threads(&self) -> ThreadsResource {
        ThreadsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    fn build_json_request<T>(
        &self,
        method: HttpMethod,
        path: &str,
        body: &T,
    ) -> Result<HttpRequest, LingerError>
    where
        T: serde::Serialize,
    {
        let mut request = HttpRequest::new(method, self.config.base_url(), path);
        apply_auth_headers(&mut request, &self.config);
        request.insert_header("content-type", "application/json");
        request.set_body(serde_json::to_vec(body)?);
        Ok(request)
    }

    fn build_empty_request(&self, method: HttpMethod, path: &str) -> HttpRequest {
        let mut request = HttpRequest::new(method, self.config.base_url(), path);
        apply_auth_headers(&mut request, &self.config);
        request
    }

    async fn send_retryable_get(&self, path: &str) -> Result<(HeaderMap, Bytes), LingerError> {
        let max_retries = self.config.retry_policy().max_retries;
        let mut retry_attempt = 0;
        loop {
            let request = self.build_empty_request(HttpMethod::Get, path);
            let response = self.transport.send(request).await?;
            let (status, headers, body) = response.into_bytes().await?;
            if (200..300).contains(&status) {
                return Ok((headers, body));
            }

            let decision = self.config.retry_policy().classify_status(status, &headers);
            let error = parse_api_error(status, headers, &body);
            match decision {
                RetryDecision::RetryAfter(delay) if retry_attempt < max_retries => {
                    let delay = delay
                        .unwrap_or_else(|| self.config.retry_policy().backoff_delay(retry_attempt));
                    self.config.retry_sleeper().sleep(delay).await;
                    retry_attempt += 1;
                }
                RetryDecision::RetryAfter(_) if max_retries > 0 => {
                    return Err(LingerError::retry_exhausted(retry_attempt + 1, error));
                }
                _ => return Err(error),
            }
        }
    }
}

/// EN: Threads API resource.
/// 中文：Threads API 资源。
#[derive(Clone, Debug)]
pub struct ThreadsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ThreadsResource {
    /// EN: Creates a Thread with `POST /v1/threads`.
    /// 中文：使用 `POST /v1/threads` 创建 Thread。
    pub async fn create(&self, request: CreateThreadRequest) -> Result<Thread, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut request = client.build_json_request(HttpMethod::Post, "/v1/threads", &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Thread>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a thread and run with `POST /v1/threads/runs`.
    /// 中文：使用 `POST /v1/threads/runs` 创建线程并运行。
    pub async fn create_and_run(
        &self,
        request: CreateThreadAndRunRequest,
    ) -> Result<ThreadRun, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut request =
            client.build_json_request(HttpMethod::Post, "/v1/threads/runs", &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a Thread with `GET /v1/threads/{thread_id}`.
    /// 中文：使用 `GET /v1/threads/{thread_id}` 获取 Thread。
    pub async fn retrieve(&self, thread_id: &str) -> Result<Thread, LingerError> {
        let thread_id = validate_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}");
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Thread>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a Thread with `POST /v1/threads/{thread_id}`.
    /// 中文：使用 `POST /v1/threads/{thread_id}` 修改 Thread。
    pub async fn modify(
        &self,
        thread_id: &str,
        request: ModifyThreadRequest,
    ) -> Result<Thread, LingerError> {
        let thread_id = validate_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Thread>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a Thread with `DELETE /v1/threads/{thread_id}`.
    /// 中文：使用 `DELETE /v1/threads/{thread_id}` 删除 Thread。
    pub async fn delete(&self, thread_id: &str) -> Result<ThreadDeletion, LingerError> {
        let thread_id = validate_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}");
        let mut request = client.build_empty_request(HttpMethod::Delete, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Thread Messages subresource for a thread id.
    /// 中文：返回指定 Thread ID 的 Thread Messages 子资源。
    pub fn messages(&self, thread_id: &str) -> ThreadMessagesResource {
        ThreadMessagesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            thread_id: thread_id.to_string(),
        }
    }

    /// EN: Returns the Thread Runs subresource for a thread id.
    /// 中文：返回指定 Thread ID 的 Thread Runs 子资源。
    pub fn runs(&self, thread_id: &str) -> ThreadRunsResource {
        ThreadRunsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            thread_id: thread_id.to_string(),
        }
    }
}

/// EN: Thread Messages API resource.
/// 中文：Thread Messages API 资源。
#[derive(Clone, Debug)]
pub struct ThreadMessagesResource {
    config: ClientConfig,
    transport: SharedTransport,
    thread_id: String,
}

impl ThreadMessagesResource {
    /// EN: Creates a thread message with `POST /v1/threads/{thread_id}/messages`.
    /// 中文：使用 `POST /v1/threads/{thread_id}/messages` 创建线程消息。
    pub async fn create(
        &self,
        request: CreateThreadMessageRequest,
    ) -> Result<ThreadMessage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/messages");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadMessage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists thread messages.
    /// 中文：列出线程消息。
    pub async fn list(&self) -> Result<ThreadMessagePage, LingerError> {
        self.list_with(ThreadMessageListRequest::default()).await
    }

    /// EN: Lists thread messages with query parameters.
    /// 中文：使用查询参数列出线程消息。
    pub async fn list_with(
        &self,
        request: ThreadMessageListRequest,
    ) -> Result<ThreadMessagePage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(thread_id);
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ThreadMessagePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a thread message.
    /// 中文：获取线程消息。
    pub async fn retrieve(&self, message_id: &str) -> Result<ThreadMessage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let message_id = validate_message_id(message_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/messages/{message_id}");
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadMessage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a thread message.
    /// 中文：修改线程消息。
    pub async fn modify(
        &self,
        message_id: &str,
        request: ModifyThreadMessageRequest,
    ) -> Result<ThreadMessage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let message_id = validate_message_id(message_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/messages/{message_id}");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadMessage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a thread message.
    /// 中文：删除线程消息。
    pub async fn delete(&self, message_id: &str) -> Result<ThreadMessageDeletion, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let message_id = validate_message_id(message_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/messages/{message_id}");
        let mut request = client.build_empty_request(HttpMethod::Delete, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ThreadMessageDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Thread Runs API resource.
/// 中文：Thread Runs API 资源。
#[derive(Clone, Debug)]
pub struct ThreadRunsResource {
    config: ClientConfig,
    transport: SharedTransport,
    thread_id: String,
}

impl ThreadRunsResource {
    /// EN: Creates a run with `POST /v1/threads/{thread_id}/runs`.
    /// 中文：使用 `POST /v1/threads/{thread_id}/runs` 创建 Run。
    pub async fn create(&self, request: CreateThreadRunRequest) -> Result<ThreadRun, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(thread_id);
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists runs for a thread.
    /// 中文：列出线程中的 Run。
    pub async fn list(&self) -> Result<ThreadRunPage, LingerError> {
        self.list_with(ThreadRunListRequest::default()).await
    }

    /// EN: Lists runs for a thread with query parameters.
    /// 中文：使用查询参数列出线程中的 Run。
    pub async fn list_with(
        &self,
        request: ThreadRunListRequest,
    ) -> Result<ThreadRunPage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(thread_id);
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRunPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a run.
    /// 中文：获取 Run。
    pub async fn retrieve(&self, run_id: &str) -> Result<ThreadRun, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/runs/{run_id}");
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a run.
    /// 中文：修改 Run。
    pub async fn modify(
        &self,
        run_id: &str,
        request: ModifyThreadRunRequest,
    ) -> Result<ThreadRun, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/runs/{run_id}");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels a run.
    /// 中文：取消 Run。
    pub async fn cancel(&self, run_id: &str) -> Result<ThreadRun, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/runs/{run_id}/cancel");
        let mut request = client.build_empty_request(HttpMethod::Post, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Submits tool outputs for a run waiting on tool calls.
    /// 中文：为等待工具调用的 Run 提交工具输出。
    pub async fn submit_tool_outputs(
        &self,
        run_id: &str,
        request: SubmitToolOutputsRequest,
    ) -> Result<ThreadRun, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/threads/{thread_id}/runs/{run_id}/submit_tool_outputs");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ThreadRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Run Steps subresource for a run id.
    /// 中文：返回指定 Run ID 的 Run Steps 子资源。
    pub fn steps(&self, run_id: &str) -> RunStepsResource {
        RunStepsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            thread_id: self.thread_id.clone(),
            run_id: run_id.to_string(),
        }
    }
}

/// EN: Run Steps API resource.
/// 中文：Run Steps API 资源。
#[derive(Clone, Debug)]
pub struct RunStepsResource {
    config: ClientConfig,
    transport: SharedTransport,
    thread_id: String,
    run_id: String,
}

impl RunStepsResource {
    /// EN: Lists run steps.
    /// 中文：列出 Run Step。
    pub async fn list(&self) -> Result<RunStepPage, LingerError> {
        self.list_with(RunStepListRequest::default()).await
    }

    /// EN: Lists run steps with query parameters.
    /// 中文：使用查询参数列出 Run Step。
    pub async fn list_with(&self, request: RunStepListRequest) -> Result<RunStepPage, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(&self.run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(thread_id, run_id);
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<RunStepPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a run step.
    /// 中文：获取 Run Step。
    pub async fn retrieve(&self, step_id: &str) -> Result<RunStep, LingerError> {
        self.retrieve_with(step_id, RunStepRetrieveRequest::default())
            .await
    }

    /// EN: Retrieves a run step with query parameters.
    /// 中文：使用查询参数获取 Run Step。
    pub async fn retrieve_with(
        &self,
        step_id: &str,
        request: RunStepRetrieveRequest,
    ) -> Result<RunStep, LingerError> {
        let thread_id = validate_thread_id(&self.thread_id)?;
        let run_id = validate_run_id(&self.run_id)?;
        let step_id = validate_step_id(step_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(thread_id, run_id, step_id);
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<RunStep>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Assistants API resource.
/// 中文：Assistants API 资源。
#[derive(Clone, Debug)]
pub struct AssistantsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AssistantsResource {
    /// EN: Creates an Assistant with `POST /v1/assistants`.
    /// 中文：使用 `POST /v1/assistants` 创建 Assistant。
    pub async fn create(&self, request: CreateAssistantRequest) -> Result<Assistant, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut request =
            client.build_json_request(HttpMethod::Post, "/v1/assistants", &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Assistant>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists Assistants with `GET /v1/assistants`.
    /// 中文：使用 `GET /v1/assistants` 列出 Assistant。
    pub async fn list(&self) -> Result<AssistantPage, LingerError> {
        self.list_with(AssistantListRequest::default()).await
    }

    /// EN: Lists Assistants with query parameters for `GET /v1/assistants`.
    /// 中文：使用查询参数列出 `GET /v1/assistants` 的 Assistant。
    pub async fn list_with(
        &self,
        request: AssistantListRequest,
    ) -> Result<AssistantPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path();
        let request = self.build_beta_empty_request(&client, HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<AssistantPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves an Assistant with `GET /v1/assistants/{assistant_id}`.
    /// 中文：使用 `GET /v1/assistants/{assistant_id}` 获取 Assistant。
    pub async fn retrieve(&self, assistant_id: &str) -> Result<Assistant, LingerError> {
        let assistant_id = validate_assistant_id(assistant_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/assistants/{assistant_id}");
        let request = self.build_beta_empty_request(&client, HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Assistant>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies an Assistant with `POST /v1/assistants/{assistant_id}`.
    /// 中文：使用 `POST /v1/assistants/{assistant_id}` 修改 Assistant。
    pub async fn modify(
        &self,
        assistant_id: &str,
        request: ModifyAssistantRequest,
    ) -> Result<Assistant, LingerError> {
        let assistant_id = validate_assistant_id(assistant_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/assistants/{assistant_id}");
        let mut request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        apply_assistants_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Assistant>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes an Assistant with `DELETE /v1/assistants/{assistant_id}`.
    /// 中文：使用 `DELETE /v1/assistants/{assistant_id}` 删除 Assistant。
    pub async fn delete(&self, assistant_id: &str) -> Result<AssistantDeletion, LingerError> {
        let assistant_id = validate_assistant_id(assistant_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/assistants/{assistant_id}");
        let request = self.build_beta_empty_request(&client, HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AssistantDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    fn build_beta_empty_request(
        &self,
        client: &Client,
        method: HttpMethod,
        path: &str,
    ) -> HttpRequest {
        let mut request = client.build_empty_request(method, path);
        apply_assistants_beta_header(&mut request);
        request
    }
}

/// EN: Vector Stores API resource.
/// 中文：Vector Stores API 资源。
#[derive(Clone, Debug)]
pub struct VectorStoresResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl VectorStoresResource {
    /// EN: Creates a vector store with `POST /v1/vector_stores`.
    /// 中文：使用 `POST /v1/vector_stores` 创建向量存储。
    pub async fn create(
        &self,
        request: CreateVectorStoreRequest,
    ) -> Result<VectorStore, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/vector_stores", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VectorStore>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists vector stores with `GET /v1/vector_stores`.
    /// 中文：使用 `GET /v1/vector_stores` 列出向量存储。
    pub async fn list(&self) -> Result<VectorStorePage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/vector_stores").await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStorePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a vector store with `GET /v1/vector_stores/{vector_store_id}`.
    /// 中文：使用 `GET /v1/vector_stores/{vector_store_id}` 获取向量存储。
    pub async fn retrieve(&self, vector_store_id: &str) -> Result<VectorStore, LingerError> {
        let vector_store_id = validate_vector_store_id(vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VectorStore>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a vector store with `POST /v1/vector_stores/{vector_store_id}`.
    /// 中文：使用 `POST /v1/vector_stores/{vector_store_id}` 修改向量存储。
    pub async fn modify(
        &self,
        vector_store_id: &str,
        request: ModifyVectorStoreRequest,
    ) -> Result<VectorStore, LingerError> {
        let vector_store_id = validate_vector_store_id(vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VectorStore>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Searches a vector store with `POST /v1/vector_stores/{vector_store_id}/search`.
    /// 中文：使用 `POST /v1/vector_stores/{vector_store_id}/search` 搜索向量存储。
    pub async fn search(
        &self,
        vector_store_id: &str,
        request: CreateVectorStoreSearchRequest,
    ) -> Result<VectorStoreSearchPage, LingerError> {
        let vector_store_id = validate_vector_store_id(vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/search");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreSearchPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a vector store with `DELETE /v1/vector_stores/{vector_store_id}`.
    /// 中文：使用 `DELETE /v1/vector_stores/{vector_store_id}` 删除向量存储。
    pub async fn delete(&self, vector_store_id: &str) -> Result<VectorStoreDeletion, LingerError> {
        let vector_store_id = validate_vector_store_id(vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Vector Store Files subresource for a vector store id.
    /// 中文：返回指定向量存储 ID 的 Vector Store Files 子资源。
    pub fn files(&self, vector_store_id: &str) -> VectorStoreFilesResource {
        VectorStoreFilesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            vector_store_id: vector_store_id.to_string(),
        }
    }

    /// EN: Returns the Vector Store File Batches subresource for a vector store id.
    /// 中文：返回指定向量存储 ID 的 Vector Store File Batches 子资源。
    pub fn file_batches(&self, vector_store_id: &str) -> VectorStoreFileBatchesResource {
        VectorStoreFileBatchesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            vector_store_id: vector_store_id.to_string(),
        }
    }
}

/// EN: Vector Store Files API resource.
/// 中文：Vector Store Files API 资源。
#[derive(Clone, Debug)]
pub struct VectorStoreFilesResource {
    config: ClientConfig,
    transport: SharedTransport,
    vector_store_id: String,
}

impl VectorStoreFilesResource {
    /// EN: Attaches a file with `POST /v1/vector_stores/{vector_store_id}/files`.
    /// 中文：使用 `POST /v1/vector_stores/{vector_store_id}/files` 附加文件。
    pub async fn create(
        &self,
        request: CreateVectorStoreFileRequest,
    ) -> Result<VectorStoreFile, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFile>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists vector store files.
    /// 中文：列出向量存储文件。
    pub async fn list(&self) -> Result<VectorStoreFilePage, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFilePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a vector store file.
    /// 中文：获取向量存储文件。
    pub async fn retrieve(&self, file_id: &str) -> Result<VectorStoreFile, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let file_id = validate_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files/{file_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFile>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves parsed vector store file content.
    /// 中文：获取向量存储文件的已解析内容。
    pub async fn content(&self, file_id: &str) -> Result<VectorStoreFileContentPage, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let file_id = validate_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files/{file_id}/content");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VectorStoreFileContentPage>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies vector store file attributes.
    /// 中文：修改向量存储文件属性。
    pub async fn modify(
        &self,
        file_id: &str,
        request: ModifyVectorStoreFileRequest,
    ) -> Result<VectorStoreFile, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let file_id = validate_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files/{file_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFile>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a vector store file.
    /// 中文：删除向量存储文件。
    pub async fn delete(&self, file_id: &str) -> Result<VectorStoreFileDeletion, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let file_id = validate_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/files/{file_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFileDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Vector Store File Batches API resource.
/// 中文：Vector Store File Batches API 资源。
#[derive(Clone, Debug)]
pub struct VectorStoreFileBatchesResource {
    config: ClientConfig,
    transport: SharedTransport,
    vector_store_id: String,
}

impl VectorStoreFileBatchesResource {
    /// EN: Creates a file batch with `POST /v1/vector_stores/{vector_store_id}/file_batches`.
    /// 中文：使用 `POST /v1/vector_stores/{vector_store_id}/file_batches` 创建文件批量。
    pub async fn create(
        &self,
        request: CreateVectorStoreFileBatchRequest,
    ) -> Result<VectorStoreFileBatch, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/file_batches");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFileBatch>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a vector store file batch.
    /// 中文：获取向量存储文件批量。
    pub async fn retrieve(&self, batch_id: &str) -> Result<VectorStoreFileBatch, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let batch_id = validate_batch_id(batch_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/file_batches/{batch_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFileBatch>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels a vector store file batch.
    /// 中文：取消向量存储文件批量。
    pub async fn cancel(&self, batch_id: &str) -> Result<VectorStoreFileBatch, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let batch_id = validate_batch_id(batch_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFileBatch>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists files in a vector store file batch.
    /// 中文：列出向量存储文件批量中的文件。
    pub async fn list_files(&self, batch_id: &str) -> Result<VectorStoreFilePage, LingerError> {
        let vector_store_id = validate_vector_store_id(&self.vector_store_id)?;
        let batch_id = validate_batch_id(batch_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/vector_stores/{vector_store_id}/file_batches/{batch_id}/files");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<VectorStoreFilePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Uploads API resource.
/// 中文：Uploads API 资源。
#[derive(Clone, Debug)]
pub struct UploadsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl UploadsResource {
    /// EN: Creates an upload with `POST /v1/uploads`.
    /// 中文：使用 `POST /v1/uploads` 创建上传。
    pub async fn create(&self, request: CreateUploadRequest) -> Result<Upload, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/uploads", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Upload>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the upload parts subresource for an upload id.
    /// 中文：返回指定上传 ID 的上传分段子资源。
    pub fn parts(&self, upload_id: &str) -> UploadPartsResource {
        UploadPartsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            upload_id: upload_id.to_string(),
        }
    }

    /// EN: Completes an upload with `POST /v1/uploads/{upload_id}/complete`.
    /// 中文：使用 `POST /v1/uploads/{upload_id}/complete` 完成上传。
    pub async fn complete(
        &self,
        upload_id: &str,
        request: CompleteUploadRequest,
    ) -> Result<Upload, LingerError> {
        let upload_id = validate_upload_id(upload_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/uploads/{upload_id}/complete");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Upload>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels an upload with `POST /v1/uploads/{upload_id}/cancel`.
    /// 中文：使用 `POST /v1/uploads/{upload_id}/cancel` 取消上传。
    pub async fn cancel(&self, upload_id: &str) -> Result<Upload, LingerError> {
        let upload_id = validate_upload_id(upload_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/uploads/{upload_id}/cancel");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Upload>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Upload Parts API resource.
/// 中文：Upload Parts API 资源。
#[derive(Clone, Debug)]
pub struct UploadPartsResource {
    config: ClientConfig,
    transport: SharedTransport,
    upload_id: String,
}

impl UploadPartsResource {
    /// EN: Adds a part to an upload with `POST /v1/uploads/{upload_id}/parts`.
    /// 中文：使用 `POST /v1/uploads/{upload_id}/parts` 向上传添加分段。
    pub async fn create(
        &self,
        request: CreateUploadPartRequest,
    ) -> Result<UploadPart, LingerError> {
        let upload_id = validate_upload_id(&self.upload_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/uploads/{upload_id}/parts");
        let mut http_request = client.build_empty_request(HttpMethod::Post, &path);
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<UploadPart>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Audio API resource.
/// 中文：Audio API 资源。
#[derive(Clone, Debug)]
pub struct AudioResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioResource {
    /// EN: Returns the Audio Speech API resource.
    /// 中文：返回 Audio Speech API 资源。
    pub fn speech(&self) -> AudioSpeechResource {
        AudioSpeechResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Audio Transcriptions API resource.
    /// 中文：返回 Audio Transcriptions API 资源。
    pub fn transcriptions(&self) -> AudioTranscriptionsResource {
        AudioTranscriptionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Audio Translations API resource.
    /// 中文：返回 Audio Translations API 资源。
    pub fn translations(&self) -> AudioTranslationsResource {
        AudioTranslationsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Audio Voice Consents API resource.
    /// 中文：返回 Audio Voice Consents API 资源。
    pub fn voice_consents(&self) -> AudioVoiceConsentsResource {
        AudioVoiceConsentsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Audio Voices API resource.
    /// 中文：返回 Audio Voices API 资源。
    pub fn voices(&self) -> AudioVoicesResource {
        AudioVoicesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Audio Speech API resource.
/// 中文：Audio Speech API 资源。
#[derive(Clone, Debug)]
pub struct AudioSpeechResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioSpeechResource {
    /// EN: Creates speech audio with `POST /v1/audio/speech`.
    /// 中文：使用 `POST /v1/audio/speech` 创建语音音频。
    pub async fn create(
        &self,
        request: CreateSpeechRequest,
    ) -> Result<AudioSpeechResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/audio/speech", &request)?;
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        let content_type = response.headers().get("content-type").map(str::to_string);
        Ok(AudioSpeechResponse::new(
            request_id,
            content_type,
            response.into_body_stream(),
        ))
    }
}

/// EN: Audio Transcriptions API resource.
/// 中文：Audio Transcriptions API 资源。
#[derive(Clone, Debug)]
pub struct AudioTranscriptionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioTranscriptionsResource {
    /// EN: Creates a transcription with `POST /v1/audio/transcriptions`.
    /// 中文：使用 `POST /v1/audio/transcriptions` 创建转写。
    pub async fn create(
        &self,
        request: CreateTranscriptionRequest,
    ) -> Result<AudioTranscription, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request =
            client.build_empty_request(HttpMethod::Post, "/v1/audio/transcriptions");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioTranscription>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Audio Translations API resource.
/// 中文：Audio Translations API 资源。
#[derive(Clone, Debug)]
pub struct AudioTranslationsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioTranslationsResource {
    /// EN: Creates a translation with `POST /v1/audio/translations`.
    /// 中文：使用 `POST /v1/audio/translations` 创建翻译。
    pub async fn create(
        &self,
        request: CreateTranslationRequest,
    ) -> Result<AudioTranslation, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request =
            client.build_empty_request(HttpMethod::Post, "/v1/audio/translations");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioTranslation>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Audio Voice Consents API resource.
/// 中文：Audio Voice Consents API 资源。
#[derive(Clone, Debug)]
pub struct AudioVoiceConsentsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioVoiceConsentsResource {
    /// EN: Creates a voice consent recording with `POST /v1/audio/voice_consents`.
    /// 中文：使用 `POST /v1/audio/voice_consents` 创建 voice consent 录音。
    pub async fn create(
        &self,
        request: CreateVoiceConsentRequest,
    ) -> Result<AudioVoiceConsent, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request =
            client.build_empty_request(HttpMethod::Post, "/v1/audio/voice_consents");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioVoiceConsent>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists voice consent recordings with `GET /v1/audio/voice_consents`.
    /// 中文：使用 `GET /v1/audio/voice_consents` 列出 voice consent 录音。
    pub async fn list(&self) -> Result<AudioVoiceConsentPage, LingerError> {
        self.list_with(AudioVoiceConsentListRequest::default())
            .await
    }

    /// EN: Lists voice consent recordings with query parameters for `GET /v1/audio/voice_consents`.
    /// 中文：使用查询参数列出 `GET /v1/audio/voice_consents` 的 voice consent 录音。
    pub async fn list_with(
        &self,
        request: AudioVoiceConsentListRequest,
    ) -> Result<AudioVoiceConsentPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path();
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioVoiceConsentPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a voice consent recording.
    /// 中文：获取 voice consent 录音。
    pub async fn retrieve(&self, voice_consent_id: &str) -> Result<AudioVoiceConsent, LingerError> {
        let voice_consent_id = validate_voice_consent_id(voice_consent_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/audio/voice_consents/{voice_consent_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioVoiceConsent>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Updates voice consent metadata with `POST /v1/audio/voice_consents/{consent_id}`.
    /// 中文：使用 `POST /v1/audio/voice_consents/{consent_id}` 更新 voice consent 元数据。
    pub async fn update(
        &self,
        voice_consent_id: &str,
        request: UpdateVoiceConsentRequest,
    ) -> Result<AudioVoiceConsent, LingerError> {
        let voice_consent_id = validate_voice_consent_id(voice_consent_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/audio/voice_consents/{voice_consent_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioVoiceConsent>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a voice consent recording.
    /// 中文：删除 voice consent 录音。
    pub async fn delete(
        &self,
        voice_consent_id: &str,
    ) -> Result<AudioVoiceConsentDeletion, LingerError> {
        let voice_consent_id = validate_voice_consent_id(voice_consent_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/audio/voice_consents/{voice_consent_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<AudioVoiceConsentDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Audio Voices API resource.
/// 中文：Audio Voices API 资源。
#[derive(Clone, Debug)]
pub struct AudioVoicesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl AudioVoicesResource {
    /// EN: Creates a custom voice with `POST /v1/audio/voices`.
    /// 中文：使用 `POST /v1/audio/voices` 创建自定义 voice。
    pub async fn create(&self, request: CreateVoiceRequest) -> Result<AudioVoice, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request = client.build_empty_request(HttpMethod::Post, "/v1/audio/voices");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<AudioVoice>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Images API resource.
/// 中文：Images API 资源。
#[derive(Clone, Debug)]
pub struct ImagesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ImagesResource {
    /// EN: Generates images with `POST /v1/images/generations`.
    /// 中文：使用 `POST /v1/images/generations` 生成图像。
    pub async fn generate(
        &self,
        request: CreateImageRequest,
    ) -> Result<ImagesResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/images/generations", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ImagesResponse>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Edits images with `POST /v1/images/edits`.
    /// 中文：使用 `POST /v1/images/edits` 编辑图像。
    pub async fn edit(
        &self,
        request: CreateImageEditRequest,
    ) -> Result<ImagesResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/images/edits", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ImagesResponse>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates image variations with `POST /v1/images/variations`.
    /// 中文：使用 `POST /v1/images/variations` 创建图像变体。
    pub async fn variation(
        &self,
        request: CreateImageVariationRequest,
    ) -> Result<ImagesResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request =
            client.build_empty_request(HttpMethod::Post, "/v1/images/variations");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ImagesResponse>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Fine-tuning API resource.
/// 中文：Fine-tuning API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FineTuningResource {
    /// EN: Returns the Fine-tuning Alpha API resource.
    /// 中文：返回 Fine-tuning Alpha API 资源。
    pub fn alpha(&self) -> FineTuningAlphaResource {
        FineTuningAlphaResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Fine-tuning Jobs API resource.
    /// 中文：返回 Fine-tuning Jobs API 资源。
    pub fn jobs(&self) -> FineTuningJobsResource {
        FineTuningJobsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Fine-tuning Checkpoints API resource.
    /// 中文：返回 Fine-tuning Checkpoints API 资源。
    pub fn checkpoints(&self) -> FineTuningCheckpointsResource {
        FineTuningCheckpointsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Fine-tuning Alpha API resource.
/// 中文：Fine-tuning Alpha API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningAlphaResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FineTuningAlphaResource {
    /// EN: Returns the Fine-tuning Alpha Graders API resource.
    /// 中文：返回 Fine-tuning Alpha Graders API 资源。
    pub fn graders(&self) -> FineTuningAlphaGradersResource {
        FineTuningAlphaGradersResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Fine-tuning Alpha Graders API resource.
/// 中文：Fine-tuning Alpha Graders API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningAlphaGradersResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FineTuningAlphaGradersResource {
    /// EN: Runs a grader with `POST /v1/fine_tuning/alpha/graders/run`.
    /// 中文：使用 `POST /v1/fine_tuning/alpha/graders/run` 运行 grader。
    pub async fn run(
        &self,
        request: RunFineTuningGraderRequest,
    ) -> Result<FineTuningGraderRun, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(
            HttpMethod::Post,
            "/v1/fine_tuning/alpha/graders/run",
            &request,
        )?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<FineTuningGraderRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Validates a grader with `POST /v1/fine_tuning/alpha/graders/validate`.
    /// 中文：使用 `POST /v1/fine_tuning/alpha/graders/validate` 校验 grader。
    pub async fn validate(
        &self,
        request: ValidateFineTuningGraderRequest,
    ) -> Result<FineTuningGraderValidation, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(
            HttpMethod::Post,
            "/v1/fine_tuning/alpha/graders/validate",
            &request,
        )?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningGraderValidation>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Fine-tuning Checkpoints API resource.
/// 中文：Fine-tuning Checkpoints API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningCheckpointsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FineTuningCheckpointsResource {
    /// EN: Returns the permissions resource for a fine-tuned model checkpoint.
    /// 中文：返回微调模型 checkpoint 的 permissions 资源。
    pub fn permissions(
        &self,
        fine_tuned_model_checkpoint: impl Into<String>,
    ) -> FineTuningCheckpointPermissionsResource {
        FineTuningCheckpointPermissionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            fine_tuned_model_checkpoint: fine_tuned_model_checkpoint.into(),
        }
    }
}

/// EN: Fine-tuning Checkpoint Permissions API resource.
/// 中文：Fine-tuning Checkpoint Permissions API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningCheckpointPermissionsResource {
    config: ClientConfig,
    transport: SharedTransport,
    fine_tuned_model_checkpoint: String,
}

impl FineTuningCheckpointPermissionsResource {
    /// EN: Creates checkpoint permissions.
    /// 中文：创建 checkpoint permissions。
    pub async fn create<I, T>(
        &self,
        project_ids: I,
    ) -> Result<FineTuningCheckpointPermissionPage, LingerError>
    where
        I: IntoIterator<Item = T>,
        T: Into<String>,
    {
        let checkpoint = validate_fine_tuned_model_checkpoint(&self.fine_tuned_model_checkpoint)?;
        let body = CreateFineTuningCheckpointPermissionRequest::new(project_ids)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/checkpoints/{checkpoint}/permissions");
        let request = client.build_json_request(HttpMethod::Post, &path, &body)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningCheckpointPermissionPage>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists checkpoint permissions.
    /// 中文：列出 checkpoint permissions。
    pub async fn list(&self) -> Result<FineTuningCheckpointPermissionPage, LingerError> {
        let checkpoint = validate_fine_tuned_model_checkpoint(&self.fine_tuned_model_checkpoint)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/checkpoints/{checkpoint}/permissions");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningCheckpointPermissionPage>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves checkpoint permissions using the deprecated retrieve endpoint.
    /// 中文：使用已弃用的 retrieve 端点获取 checkpoint permissions。
    pub async fn retrieve(&self) -> Result<FineTuningCheckpointPermissionPage, LingerError> {
        self.list().await
    }

    /// EN: Deletes a checkpoint permission.
    /// 中文：删除 checkpoint permission。
    pub async fn delete(
        &self,
        permission_id: &str,
    ) -> Result<FineTuningCheckpointPermissionDeletion, LingerError> {
        let checkpoint = validate_fine_tuned_model_checkpoint(&self.fine_tuned_model_checkpoint)?;
        let permission_id = validate_checkpoint_permission_id(permission_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/checkpoints/{checkpoint}/permissions/{permission_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningCheckpointPermissionDeletion>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Fine-tuning Jobs API resource.
/// 中文：Fine-tuning Jobs API 资源。
#[derive(Clone, Debug)]
pub struct FineTuningJobsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FineTuningJobsResource {
    /// EN: Creates a fine-tuning job with `POST /v1/fine_tuning/jobs`.
    /// 中文：使用 `POST /v1/fine_tuning/jobs` 创建 fine-tuning job。
    pub async fn create(
        &self,
        request: CreateFineTuningJobRequest,
    ) -> Result<FineTuningJob, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/fine_tuning/jobs", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningJob>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists fine-tuning jobs with `GET /v1/fine_tuning/jobs`.
    /// 中文：使用 `GET /v1/fine_tuning/jobs` 列出 fine-tuning job。
    pub async fn list(&self) -> Result<FineTuningJobPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/fine_tuning/jobs").await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<FineTuningJobPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a fine-tuning job with `GET /v1/fine_tuning/jobs/{fine_tuning_job_id}`.
    /// 中文：使用 `GET /v1/fine_tuning/jobs/{fine_tuning_job_id}` 获取 fine-tuning job。
    pub async fn retrieve(&self, fine_tuning_job_id: &str) -> Result<FineTuningJob, LingerError> {
        let fine_tuning_job_id = validate_fine_tuning_job_id(fine_tuning_job_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/jobs/{fine_tuning_job_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningJob>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists fine-tuning job events.
    /// 中文：列出 fine-tuning job 事件。
    pub async fn list_events(
        &self,
        fine_tuning_job_id: &str,
    ) -> Result<FineTuningEventPage, LingerError> {
        let fine_tuning_job_id = validate_fine_tuning_job_id(fine_tuning_job_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/jobs/{fine_tuning_job_id}/events");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<FineTuningEventPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists fine-tuning job checkpoints.
    /// 中文：列出 fine-tuning job 检查点。
    pub async fn list_checkpoints(
        &self,
        fine_tuning_job_id: &str,
    ) -> Result<FineTuningCheckpointPage, LingerError> {
        let fine_tuning_job_id = validate_fine_tuning_job_id(fine_tuning_job_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<FineTuningCheckpointPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels a fine-tuning job.
    /// 中文：取消 fine-tuning job。
    pub async fn cancel(&self, fine_tuning_job_id: &str) -> Result<FineTuningJob, LingerError> {
        self.post_state_change(fine_tuning_job_id, "cancel").await
    }

    /// EN: Pauses a fine-tuning job.
    /// 中文：暂停 fine-tuning job。
    pub async fn pause(&self, fine_tuning_job_id: &str) -> Result<FineTuningJob, LingerError> {
        self.post_state_change(fine_tuning_job_id, "pause").await
    }

    /// EN: Resumes a fine-tuning job.
    /// 中文：恢复 fine-tuning job。
    pub async fn resume(&self, fine_tuning_job_id: &str) -> Result<FineTuningJob, LingerError> {
        self.post_state_change(fine_tuning_job_id, "resume").await
    }

    async fn post_state_change(
        &self,
        fine_tuning_job_id: &str,
        action: &str,
    ) -> Result<FineTuningJob, LingerError> {
        let fine_tuning_job_id = validate_fine_tuning_job_id(fine_tuning_job_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/fine_tuning/jobs/{fine_tuning_job_id}/{action}");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FineTuningJob>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Batches API resource.
/// 中文：Batches API 资源。
#[derive(Clone, Debug)]
pub struct BatchesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl BatchesResource {
    /// EN: Creates a batch with `POST /v1/batches`.
    /// 中文：使用 `POST /v1/batches` 创建 batch。
    pub async fn create(&self, request: CreateBatchRequest) -> Result<Batch, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/batches", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Batch>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists batches with `GET /v1/batches`.
    /// 中文：使用 `GET /v1/batches` 列出 batch。
    pub async fn list(&self) -> Result<BatchListPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/batches").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<BatchListPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a batch with `GET /v1/batches/{batch_id}`.
    /// 中文：使用 `GET /v1/batches/{batch_id}` 获取 batch。
    pub async fn retrieve(&self, batch_id: &str) -> Result<Batch, LingerError> {
        let batch_id = batch_id.trim();
        if batch_id.is_empty() {
            return Err(LingerError::invalid_config("batch_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/batches/{batch_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Batch>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels a batch with `POST /v1/batches/{batch_id}/cancel`.
    /// 中文：使用 `POST /v1/batches/{batch_id}/cancel` 取消 batch。
    pub async fn cancel(&self, batch_id: &str) -> Result<Batch, LingerError> {
        let batch_id = batch_id.trim();
        if batch_id.is_empty() {
            return Err(LingerError::invalid_config("batch_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/batches/{batch_id}/cancel");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Batch>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Files API resource.
/// 中文：Files API 资源。
#[derive(Clone, Debug)]
pub struct FilesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl FilesResource {
    /// EN: Uploads a file with `POST /v1/files`.
    /// 中文：使用 `POST /v1/files` 上传文件。
    pub async fn create(&self, request: CreateFileRequest) -> Result<FileObject, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request = client.build_empty_request(HttpMethod::Post, "/v1/files");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FileObject>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists files with `GET /v1/files`.
    /// 中文：使用 `GET /v1/files` 列出文件。
    pub async fn list(&self) -> Result<FilesPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/files").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FilesPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a file with `GET /v1/files/{file_id}`.
    /// 中文：使用 `GET /v1/files/{file_id}` 获取文件。
    pub async fn retrieve(&self, file_id: &str) -> Result<FileObject, LingerError> {
        let file_id = file_id.trim();
        if file_id.is_empty() {
            return Err(LingerError::invalid_config("file_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/files/{file_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FileObject>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a file with `DELETE /v1/files/{file_id}`.
    /// 中文：使用 `DELETE /v1/files/{file_id}` 删除文件。
    pub async fn delete(&self, file_id: &str) -> Result<FileDeletion, LingerError> {
        let file_id = file_id.trim();
        if file_id.is_empty() {
            return Err(LingerError::invalid_config("file_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/files/{file_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<FileDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Downloads file content with `GET /v1/files/{file_id}/content`.
    /// 中文：使用 `GET /v1/files/{file_id}/content` 下载文件内容。
    pub async fn content(&self, file_id: &str) -> Result<FileContent, LingerError> {
        let file_id = file_id.trim();
        if file_id.is_empty() {
            return Err(LingerError::invalid_config("file_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/files/{file_id}/content");
        let request = client.build_empty_request(HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        Ok(FileContent::new(request_id, response.into_body_stream()))
    }
}

/// EN: Moderations API resource.
/// 中文：Moderations API 资源。
#[derive(Clone, Debug)]
pub struct ModerationsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ModerationsResource {
    /// EN: Creates a moderation with `POST /v1/moderations`.
    /// 中文：使用 `POST /v1/moderations` 创建 moderation。
    pub async fn create(
        &self,
        request: CreateModerationRequest,
    ) -> Result<ModerationCreateResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/moderations", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ModerationCreateResponse>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Containers API resource.
/// 中文：Containers API 资源。
#[derive(Clone, Debug)]
pub struct ContainersResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ContainersResource {
    /// EN: Creates a container with `POST /v1/containers`.
    /// 中文：使用 `POST /v1/containers` 创建容器。
    pub async fn create(&self, request: CreateContainerRequest) -> Result<Container, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/containers", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Container>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists containers with `GET /v1/containers`.
    /// 中文：使用 `GET /v1/containers` 列出容器。
    pub async fn list(&self) -> Result<ContainerPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/containers").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ContainerPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a container with `GET /v1/containers/{container_id}`.
    /// 中文：使用 `GET /v1/containers/{container_id}` 获取容器。
    pub async fn retrieve(&self, container_id: &str) -> Result<Container, LingerError> {
        let container_id = validate_container_id(container_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Container>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a container with `DELETE /v1/containers/{container_id}`.
    /// 中文：使用 `DELETE /v1/containers/{container_id}` 删除容器。
    pub async fn delete(&self, container_id: &str) -> Result<ContainerDeletion, LingerError> {
        let container_id = validate_container_id(container_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ContainerDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Container Files subresource for a container id.
    /// 中文：返回指定容器 ID 的 Container Files 子资源。
    pub fn files(&self, container_id: &str) -> ContainerFilesResource {
        ContainerFilesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            container_id: container_id.to_string(),
        }
    }
}

/// EN: Container Files API resource.
/// 中文：Container Files API 资源。
#[derive(Clone, Debug)]
pub struct ContainerFilesResource {
    config: ClientConfig,
    transport: SharedTransport,
    container_id: String,
}

impl ContainerFilesResource {
    /// EN: Creates a container file with `POST /v1/containers/{container_id}/files`.
    /// 中文：使用 `POST /v1/containers/{container_id}/files` 创建容器文件。
    pub async fn create(
        &self,
        request: CreateContainerFileRequest,
    ) -> Result<ContainerFile, LingerError> {
        let container_id = validate_container_id(&self.container_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}/files");
        let mut http_request = client.build_empty_request(HttpMethod::Post, &path);
        request.apply_body(&mut http_request)?;
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ContainerFile>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists files in a container.
    /// 中文：列出容器中的文件。
    pub async fn list(&self) -> Result<ContainerFilePage, LingerError> {
        let container_id = validate_container_id(&self.container_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}/files");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ContainerFilePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a container file.
    /// 中文：获取容器文件。
    pub async fn retrieve(&self, file_id: &str) -> Result<ContainerFile, LingerError> {
        let container_id = validate_container_id(&self.container_id)?;
        let file_id = validate_container_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}/files/{file_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ContainerFile>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a container file.
    /// 中文：删除容器文件。
    pub async fn delete(&self, file_id: &str) -> Result<ContainerFileDeletion, LingerError> {
        let container_id = validate_container_id(&self.container_id)?;
        let file_id = validate_container_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}/files/{file_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ContainerFileDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Streams container file content.
    /// 中文：流式读取容器文件内容。
    pub async fn content(&self, file_id: &str) -> Result<ContainerFileContent, LingerError> {
        let container_id = validate_container_id(&self.container_id)?;
        let file_id = validate_container_file_id(file_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/containers/{container_id}/files/{file_id}/content");
        let request = client.build_empty_request(HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        let (_, _, body) = response.into_parts();
        Ok(ContainerFileContent::new(request_id, body))
    }
}

/// EN: Legacy Completions API resource.
/// 中文：Legacy Completions API 资源。
#[derive(Clone, Debug)]
pub struct CompletionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl CompletionsResource {
    /// EN: Creates a completion with `POST /v1/completions`.
    /// 中文：使用 `POST /v1/completions` 创建 completion。
    pub async fn create(
        &self,
        request: CreateCompletionRequest,
    ) -> Result<Completion, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/completions", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Completion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a streaming completion with `POST /v1/completions`.
    /// 中文：使用 `POST /v1/completions` 创建流式 completion。
    pub async fn create_stream(
        &self,
        request: CreateCompletionRequest,
    ) -> Result<CompletionStream, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = request.into_streaming();
        let request = client.build_json_request(HttpMethod::Post, "/v1/completions", &request)?;
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(CompletionStream::new(response.into_body_stream()))
    }
}

/// EN: Chat API resource.
/// 中文：Chat API 资源。
#[derive(Clone, Debug)]
pub struct ChatResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatResource {
    /// EN: Returns the Chat Completions API resource.
    /// 中文：返回 Chat Completions API 资源。
    pub fn completions(&self) -> ChatCompletionsResource {
        ChatCompletionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Chat Completions API resource.
/// 中文：Chat Completions API 资源。
#[derive(Clone, Debug)]
pub struct ChatCompletionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatCompletionsResource {
    /// EN: Creates a chat completion with `POST /v1/chat/completions`.
    /// 中文：使用 `POST /v1/chat/completions` 创建 chat completion。
    pub async fn create(
        &self,
        request: CreateChatCompletionRequest,
    ) -> Result<ChatCompletion, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/chat/completions", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatCompletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists stored chat completions with `GET /v1/chat/completions`.
    /// 中文：使用 `GET /v1/chat/completions` 列出已存储的 chat completion。
    pub async fn list(&self) -> Result<ChatCompletionPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/chat/completions").await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatCompletionPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a stored chat completion with `GET /v1/chat/completions/{completion_id}`.
    /// 中文：使用 `GET /v1/chat/completions/{completion_id}` 获取已存储的 chat completion。
    pub async fn retrieve(&self, completion_id: &str) -> Result<ChatCompletion, LingerError> {
        let completion_id = validate_chat_completion_id(completion_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chat/completions/{completion_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatCompletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a stored chat completion with `POST /v1/chat/completions/{completion_id}`.
    /// 中文：使用 `POST /v1/chat/completions/{completion_id}` 修改已存储的 chat completion。
    pub async fn modify(
        &self,
        completion_id: &str,
        request: ModifyChatCompletionRequest,
    ) -> Result<ChatCompletion, LingerError> {
        let completion_id = validate_chat_completion_id(completion_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chat/completions/{completion_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatCompletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a stored chat completion with `DELETE /v1/chat/completions/{completion_id}`.
    /// 中文：使用 `DELETE /v1/chat/completions/{completion_id}` 删除已存储的 chat completion。
    pub async fn delete(&self, completion_id: &str) -> Result<ChatCompletionDeletion, LingerError> {
        let completion_id = validate_chat_completion_id(completion_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chat/completions/{completion_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatCompletionDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the stored chat completion messages subresource.
    /// 中文：返回已存储 chat completion 消息子资源。
    pub fn messages(&self) -> ChatCompletionMessagesResource {
        ChatCompletionMessagesResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Stored Chat Completion Messages API resource.
/// 中文：已存储 Chat Completion Messages API 资源。
#[derive(Clone, Debug)]
pub struct ChatCompletionMessagesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatCompletionMessagesResource {
    /// EN: Lists stored chat completion messages.
    /// 中文：列出已存储 chat completion 的消息。
    pub async fn list(
        &self,
        completion_id: &str,
    ) -> Result<ChatCompletionMessagePage, LingerError> {
        let completion_id = validate_chat_completion_id(completion_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chat/completions/{completion_id}/messages");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatCompletionMessagePage>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: ChatKit beta API resource.
/// 中文：ChatKit beta API 资源。
#[derive(Clone, Debug)]
pub struct ChatKitResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatKitResource {
    /// EN: Returns the ChatKit Sessions subresource.
    /// 中文：返回 ChatKit Sessions 子资源。
    pub fn sessions(&self) -> ChatKitSessionsResource {
        ChatKitSessionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the ChatKit Threads subresource.
    /// 中文：返回 ChatKit Threads 子资源。
    pub fn threads(&self) -> ChatKitThreadsResource {
        ChatKitThreadsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: ChatKit Sessions beta API resource.
/// 中文：ChatKit Sessions beta API 资源。
#[derive(Clone, Debug)]
pub struct ChatKitSessionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatKitSessionsResource {
    /// EN: Creates a ChatKit session with `POST /v1/chatkit/sessions`.
    /// 中文：使用 `POST /v1/chatkit/sessions` 创建 ChatKit session。
    pub async fn create(
        &self,
        request: CreateChatKitSessionRequest,
    ) -> Result<ChatKitSession, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut request =
            client.build_json_request(HttpMethod::Post, "/v1/chatkit/sessions", &request)?;
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatKitSession>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels a ChatKit session with `POST /v1/chatkit/sessions/{session_id}/cancel`.
    /// 中文：使用 `POST /v1/chatkit/sessions/{session_id}/cancel` 取消 ChatKit session。
    pub async fn cancel(&self, session_id: &str) -> Result<ChatKitSession, LingerError> {
        let session_id = validate_chatkit_session_id(session_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chatkit/sessions/{session_id}/cancel");
        let mut request = client.build_empty_request(HttpMethod::Post, &path);
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatKitSession>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: ChatKit Threads beta API resource.
/// 中文：ChatKit Threads beta API 资源。
#[derive(Clone, Debug)]
pub struct ChatKitThreadsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ChatKitThreadsResource {
    /// EN: Lists ChatKit threads with `GET /v1/chatkit/threads`.
    /// 中文：使用 `GET /v1/chatkit/threads` 列出 ChatKit threads。
    pub async fn list(&self) -> Result<ChatKitThreadPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut request = client.build_empty_request(HttpMethod::Get, "/v1/chatkit/threads");
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatKitThreadPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists items for a ChatKit thread with `GET /v1/chatkit/threads/{thread_id}/items`.
    /// 中文：使用 `GET /v1/chatkit/threads/{thread_id}/items` 列出 ChatKit thread items。
    pub async fn list_items(&self, thread_id: &str) -> Result<ChatKitThreadItemPage, LingerError> {
        let thread_id = validate_chatkit_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chatkit/threads/{thread_id}/items");
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatKitThreadItemPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a ChatKit thread with `GET /v1/chatkit/threads/{thread_id}`.
    /// 中文：使用 `GET /v1/chatkit/threads/{thread_id}` 获取 ChatKit thread。
    pub async fn retrieve(&self, thread_id: &str) -> Result<ChatKitThread, LingerError> {
        let thread_id = validate_chatkit_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chatkit/threads/{thread_id}");
        let mut request = client.build_empty_request(HttpMethod::Get, &path);
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ChatKitThread>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a ChatKit thread with `DELETE /v1/chatkit/threads/{thread_id}`.
    /// 中文：使用 `DELETE /v1/chatkit/threads/{thread_id}` 删除 ChatKit thread。
    pub async fn delete(&self, thread_id: &str) -> Result<ChatKitThreadDeletion, LingerError> {
        let thread_id = validate_chatkit_thread_id(thread_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/chatkit/threads/{thread_id}");
        let mut request = client.build_empty_request(HttpMethod::Delete, &path);
        apply_chatkit_beta_header(&mut request);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ChatKitThreadDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Embeddings API resource.
/// 中文：Embeddings API 资源。
#[derive(Clone, Debug)]
pub struct EmbeddingsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl EmbeddingsResource {
    /// EN: Creates embeddings with `POST /v1/embeddings`.
    /// 中文：使用 `POST /v1/embeddings` 创建 embeddings。
    pub async fn create(
        &self,
        request: CreateEmbeddingRequest,
    ) -> Result<EmbeddingResponse, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/embeddings", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<EmbeddingResponse>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Realtime API resource.
/// 中文：Realtime API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeResource {
    /// EN: Returns the Realtime Calls API resource.
    /// 中文：返回 Realtime Calls API 资源。
    pub fn calls(&self) -> RealtimeCallsResource {
        RealtimeCallsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Realtime Sessions API resource.
    /// 中文：返回 Realtime Sessions API 资源。
    pub fn sessions(&self) -> RealtimeSessionsResource {
        RealtimeSessionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Realtime Transcription Sessions API resource.
    /// 中文：返回 Realtime Transcription Sessions API 资源。
    pub fn transcription_sessions(&self) -> RealtimeTranscriptionSessionsResource {
        RealtimeTranscriptionSessionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Realtime Translations API resource.
    /// 中文：返回 Realtime Translations API 资源。
    pub fn translations(&self) -> RealtimeTranslationsResource {
        RealtimeTranslationsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }

    /// EN: Returns the Realtime Client Secrets subresource.
    /// 中文：返回 Realtime Client Secrets 子资源。
    pub fn client_secrets(&self) -> RealtimeClientSecretsResource {
        RealtimeClientSecretsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Realtime Calls API resource.
/// 中文：Realtime Calls API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeCallsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeCallsResource {
    /// EN: Creates a realtime call with `POST /v1/realtime/calls`.
    /// 中文：使用 `POST /v1/realtime/calls` 创建 realtime call。
    pub async fn create(
        &self,
        request: CreateRealtimeCallRequest,
    ) -> Result<RealtimeCallSdpAnswer, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request = client.build_empty_request(HttpMethod::Post, "/v1/realtime/calls");
        request.apply_body(&mut http_request)?;
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        RealtimeCallSdpAnswer::from_parts(&headers, request_id, body)
    }

    /// EN: Accepts an incoming realtime call with `POST /v1/realtime/calls/{call_id}/accept`.
    /// 中文：使用 `POST /v1/realtime/calls/{call_id}/accept` 接听传入的 realtime call。
    pub async fn accept(
        &self,
        call_id: &str,
        request: CreateRealtimeSessionRequest,
    ) -> Result<(), LingerError> {
        let call_id = validate_realtime_call_id(call_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/realtime/calls/{call_id}/accept");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(())
    }

    /// EN: Hangs up a realtime call with `POST /v1/realtime/calls/{call_id}/hangup`.
    /// 中文：使用 `POST /v1/realtime/calls/{call_id}/hangup` 挂断 realtime call。
    pub async fn hangup(&self, call_id: &str) -> Result<(), LingerError> {
        let call_id = validate_realtime_call_id(call_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/realtime/calls/{call_id}/hangup");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(())
    }

    /// EN: Rejects an incoming realtime call with `POST /v1/realtime/calls/{call_id}/reject`.
    /// 中文：使用 `POST /v1/realtime/calls/{call_id}/reject` 拒绝传入的 realtime call。
    pub async fn reject(&self, call_id: &str) -> Result<(), LingerError> {
        let call_id = validate_realtime_call_id(call_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/realtime/calls/{call_id}/reject");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(())
    }

    /// EN: Rejects an incoming realtime call with an optional SIP status code.
    /// 中文：使用可选 SIP 状态码拒绝传入的 realtime call。
    pub async fn reject_with(
        &self,
        call_id: &str,
        request: RejectRealtimeCallRequest,
    ) -> Result<(), LingerError> {
        let call_id = validate_realtime_call_id(call_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/realtime/calls/{call_id}/reject");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(())
    }

    /// EN: Refers an active realtime call with `POST /v1/realtime/calls/{call_id}/refer`.
    /// 中文：使用 `POST /v1/realtime/calls/{call_id}/refer` 转接活跃的 realtime call。
    pub async fn refer(
        &self,
        call_id: &str,
        request: CreateRealtimeCallReferRequest,
    ) -> Result<(), LingerError> {
        let call_id = validate_realtime_call_id(call_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/realtime/calls/{call_id}/refer");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(())
    }
}

/// EN: Realtime Sessions API resource.
/// 中文：Realtime Sessions API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeSessionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeSessionsResource {
    /// EN: Creates a realtime session with `POST /v1/realtime/sessions`.
    /// 中文：使用 `POST /v1/realtime/sessions` 创建 realtime session。
    pub async fn create(
        &self,
        request: CreateRealtimeSessionRequest,
    ) -> Result<RealtimeSession, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/realtime/sessions", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<RealtimeSession>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Realtime Transcription Sessions API resource.
/// 中文：Realtime Transcription Sessions API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeTranscriptionSessionsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeTranscriptionSessionsResource {
    /// EN: Creates a realtime transcription session with `POST /v1/realtime/transcription_sessions`.
    /// 中文：使用 `POST /v1/realtime/transcription_sessions` 创建 realtime transcription session。
    pub async fn create(
        &self,
        request: CreateRealtimeTranscriptionSessionRequest,
    ) -> Result<RealtimeTranscriptionSession, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(
            HttpMethod::Post,
            "/v1/realtime/transcription_sessions",
            &request,
        )?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<RealtimeTranscriptionSession>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Realtime Translations API resource.
/// 中文：Realtime Translations API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeTranslationsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeTranslationsResource {
    /// EN: Returns the Realtime Translation Client Secrets API resource.
    /// 中文：返回 Realtime Translation Client Secrets API 资源。
    pub fn client_secrets(&self) -> RealtimeTranslationClientSecretsResource {
        RealtimeTranslationClientSecretsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Realtime Translation Client Secrets API resource.
/// 中文：Realtime Translation Client Secrets API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeTranslationClientSecretsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeTranslationClientSecretsResource {
    /// EN: Creates a realtime translation client secret with `POST /v1/realtime/translations/client_secrets`.
    /// 中文：使用 `POST /v1/realtime/translations/client_secrets` 创建 realtime translation client secret。
    pub async fn create(
        &self,
        request: CreateRealtimeTranslationClientSecretRequest,
    ) -> Result<RealtimeTranslationClientSecret, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(
            HttpMethod::Post,
            "/v1/realtime/translations/client_secrets",
            &request,
        )?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<RealtimeTranslationClientSecret>(&body)?
            .with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Realtime Client Secrets API resource.
/// 中文：Realtime Client Secrets API 资源。
#[derive(Clone, Debug)]
pub struct RealtimeClientSecretsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl RealtimeClientSecretsResource {
    /// EN: Creates a realtime client secret with `POST /v1/realtime/client_secrets`.
    /// 中文：使用 `POST /v1/realtime/client_secrets` 创建 realtime client secret。
    pub async fn create(
        &self,
        request: CreateRealtimeClientSecretRequest,
    ) -> Result<RealtimeClientSecret, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/realtime/client_secrets", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<RealtimeClientSecret>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Evals API resource.
/// 中文：Evals API 资源。
#[derive(Clone, Debug)]
pub struct EvalsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl EvalsResource {
    /// EN: Creates an eval with `POST /v1/evals`.
    /// 中文：使用 `POST /v1/evals` 创建 eval。
    pub async fn create(&self, request: CreateEvalRequest) -> Result<Eval, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/evals", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Eval>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists evals with `GET /v1/evals`.
    /// 中文：使用 `GET /v1/evals` 列出 eval。
    pub async fn list(&self) -> Result<EvalPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/evals").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves an eval with `GET /v1/evals/{eval_id}`.
    /// 中文：使用 `GET /v1/evals/{eval_id}` 获取 eval。
    pub async fn retrieve(&self, eval_id: &str) -> Result<Eval, LingerError> {
        let eval_id = validate_eval_id(eval_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Eval>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies an eval with `POST /v1/evals/{eval_id}`.
    /// 中文：使用 `POST /v1/evals/{eval_id}` 修改 eval。
    pub async fn modify(
        &self,
        eval_id: &str,
        request: ModifyEvalRequest,
    ) -> Result<Eval, LingerError> {
        let eval_id = validate_eval_id(eval_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Eval>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes an eval with `DELETE /v1/evals/{eval_id}`.
    /// 中文：使用 `DELETE /v1/evals/{eval_id}` 删除 eval。
    pub async fn delete(&self, eval_id: &str) -> Result<EvalDeletion, LingerError> {
        let eval_id = validate_eval_id(eval_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Eval Runs subresource for an eval id.
    /// 中文：返回指定 eval ID 的 Eval Runs 子资源。
    pub fn runs(&self, eval_id: &str) -> EvalRunsResource {
        EvalRunsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            eval_id: eval_id.to_string(),
        }
    }
}

/// EN: Eval Runs API resource.
/// 中文：Eval Runs API 资源。
#[derive(Clone, Debug)]
pub struct EvalRunsResource {
    config: ClientConfig,
    transport: SharedTransport,
    eval_id: String,
}

impl EvalRunsResource {
    /// EN: Creates an eval run with `POST /v1/evals/{eval_id}/runs`.
    /// 中文：使用 `POST /v1/evals/{eval_id}/runs` 创建 eval run。
    pub async fn create(&self, request: CreateEvalRunRequest) -> Result<EvalRun, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists eval runs with `GET /v1/evals/{eval_id}/runs`.
    /// 中文：使用 `GET /v1/evals/{eval_id}/runs` 列出 eval run。
    pub async fn list(&self) -> Result<EvalRunPage, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalRunPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves an eval run with `GET /v1/evals/{eval_id}/runs/{run_id}`.
    /// 中文：使用 `GET /v1/evals/{eval_id}/runs/{run_id}` 获取 eval run。
    pub async fn retrieve(&self, run_id: &str) -> Result<EvalRun, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let run_id = validate_eval_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs/{run_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels an eval run with `POST /v1/evals/{eval_id}/runs/{run_id}/cancel`.
    /// 中文：使用 `POST /v1/evals/{eval_id}/runs/{run_id}/cancel` 取消 eval run。
    pub async fn cancel(&self, run_id: &str) -> Result<EvalRun, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let run_id = validate_eval_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs/{run_id}/cancel");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<EvalRun>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes an eval run with `DELETE /v1/evals/{eval_id}/runs/{run_id}`.
    /// 中文：使用 `DELETE /v1/evals/{eval_id}/runs/{run_id}` 删除 eval run。
    pub async fn delete(&self, run_id: &str) -> Result<EvalRunDeletion, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let run_id = validate_eval_run_id(run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs/{run_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<EvalRunDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Eval Run Output Items subresource for a run id.
    /// 中文：返回指定 run ID 的 Eval Run Output Items 子资源。
    pub fn output_items(&self, run_id: &str) -> EvalRunOutputItemsResource {
        EvalRunOutputItemsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            eval_id: self.eval_id.clone(),
            run_id: run_id.to_string(),
        }
    }
}

/// EN: Eval Run Output Items API resource.
/// 中文：Eval Run Output Items API 资源。
#[derive(Clone, Debug)]
pub struct EvalRunOutputItemsResource {
    config: ClientConfig,
    transport: SharedTransport,
    eval_id: String,
    run_id: String,
}

impl EvalRunOutputItemsResource {
    /// EN: Lists eval run output items.
    /// 中文：列出 eval run output item。
    pub async fn list(&self) -> Result<EvalRunOutputItemPage, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let run_id = validate_eval_run_id(&self.run_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs/{run_id}/output_items");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<EvalRunOutputItemPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves an eval run output item.
    /// 中文：获取 eval run output item。
    pub async fn retrieve(&self, output_item_id: &str) -> Result<EvalRunOutputItem, LingerError> {
        let eval_id = validate_eval_id(&self.eval_id)?;
        let run_id = validate_eval_run_id(&self.run_id)?;
        let output_item_id = validate_eval_run_output_item_id(output_item_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/evals/{eval_id}/runs/{run_id}/output_items/{output_item_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<EvalRunOutputItem>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Conversations API resource.
/// 中文：Conversations API 资源。
#[derive(Clone, Debug)]
pub struct ConversationsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ConversationsResource {
    /// EN: Creates a conversation with `POST /v1/conversations`.
    /// 中文：使用 `POST /v1/conversations` 创建会话。
    pub async fn create(
        &self,
        request: CreateConversationRequest,
    ) -> Result<Conversation, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/conversations", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Conversation>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a conversation with `GET /v1/conversations/{conversation_id}`.
    /// 中文：使用 `GET /v1/conversations/{conversation_id}` 获取会话。
    pub async fn retrieve(&self, conversation_id: &str) -> Result<Conversation, LingerError> {
        let conversation_id = validate_conversation_id(conversation_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Conversation>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Modifies a conversation with `POST /v1/conversations/{conversation_id}`.
    /// 中文：使用 `POST /v1/conversations/{conversation_id}` 修改会话。
    pub async fn modify(
        &self,
        conversation_id: &str,
        request: ModifyConversationRequest,
    ) -> Result<Conversation, LingerError> {
        let conversation_id = validate_conversation_id(conversation_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Conversation>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a conversation with `DELETE /v1/conversations/{conversation_id}`.
    /// 中文：使用 `DELETE /v1/conversations/{conversation_id}` 删除会话。
    pub async fn delete(&self, conversation_id: &str) -> Result<ConversationDeletion, LingerError> {
        let conversation_id = validate_conversation_id(conversation_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ConversationDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Conversation Items subresource for a conversation id.
    /// 中文：返回指定 Conversation ID 的 Conversation Items 子资源。
    pub fn items(&self, conversation_id: &str) -> ConversationItemsResource {
        ConversationItemsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            conversation_id: conversation_id.to_string(),
        }
    }
}

/// EN: Conversation Items API resource.
/// 中文：Conversation Items API 资源。
#[derive(Clone, Debug)]
pub struct ConversationItemsResource {
    config: ClientConfig,
    transport: SharedTransport,
    conversation_id: String,
}

impl ConversationItemsResource {
    /// EN: Creates a conversation item with `POST /v1/conversations/{conversation_id}/items`.
    /// 中文：使用 `POST /v1/conversations/{conversation_id}/items` 创建会话项。
    pub async fn create(
        &self,
        request: CreateConversationItemRequest,
    ) -> Result<ConversationItem, LingerError> {
        let conversation_id = validate_conversation_id(&self.conversation_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}/items");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ConversationItem>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists conversation items.
    /// 中文：列出会话项。
    pub async fn list(&self) -> Result<ConversationItemPage, LingerError> {
        let conversation_id = validate_conversation_id(&self.conversation_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}/items");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ConversationItemPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a conversation item.
    /// 中文：获取会话项。
    pub async fn retrieve(&self, item_id: &str) -> Result<ConversationItem, LingerError> {
        let conversation_id = validate_conversation_id(&self.conversation_id)?;
        let item_id = validate_conversation_item_id(item_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}/items/{item_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ConversationItem>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a conversation item.
    /// 中文：删除会话项。
    pub async fn delete(&self, item_id: &str) -> Result<ConversationItemDeletion, LingerError> {
        let conversation_id = validate_conversation_id(&self.conversation_id)?;
        let item_id = validate_conversation_item_id(item_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/conversations/{conversation_id}/items/{item_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ConversationItemDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Models API resource.
/// 中文：Models API 资源。
#[derive(Clone, Debug)]
pub struct ModelsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ModelsResource {
    /// EN: Lists currently available models with `GET /v1/models`.
    /// 中文：使用 `GET /v1/models` 列出当前可用模型。
    pub async fn list(&self) -> Result<ModelsPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/models").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ModelsPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a model with `GET /v1/models/{model}`.
    /// 中文：使用 `GET /v1/models/{model}` 获取模型。
    pub async fn retrieve(&self, model: &str) -> Result<Model, LingerError> {
        let model = model.trim();
        if model.is_empty() {
            return Err(LingerError::invalid_config("model is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/models/{model}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Model>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a fine-tuned model with `DELETE /v1/models/{model}`.
    /// 中文：使用 `DELETE /v1/models/{model}` 删除微调模型。
    pub async fn delete(&self, model: &str) -> Result<ModelDeletion, LingerError> {
        let model = model.trim();
        if model.is_empty() {
            return Err(LingerError::invalid_config("model is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/models/{model}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<ModelDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Videos API resource.
/// 中文：Videos API 资源。
#[derive(Clone, Debug)]
pub struct VideosResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl VideosResource {
    /// EN: Creates a video with `POST /v1/videos`.
    /// 中文：使用 `POST /v1/videos` 创建 video。
    pub async fn create(&self, request: CreateVideoRequest) -> Result<Video, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/videos", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Video>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a video edit with `POST /v1/videos/edits`.
    /// 中文：使用 `POST /v1/videos/edits` 创建 video edit。
    pub async fn edit(&self, request: CreateVideoEditRequest) -> Result<Video, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/videos/edits", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Video>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a video extension with `POST /v1/videos/extensions`.
    /// 中文：使用 `POST /v1/videos/extensions` 创建 video extension。
    pub async fn extend(&self, request: CreateVideoExtensionRequest) -> Result<Video, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/videos/extensions", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Video>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists videos with `GET /v1/videos`.
    /// 中文：使用 `GET /v1/videos` 列出 videos。
    pub async fn list(&self) -> Result<VideoPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let (headers, body) = client.send_retryable_get("/v1/videos").await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VideoPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a video with `GET /v1/videos/{video_id}`.
    /// 中文：使用 `GET /v1/videos/{video_id}` 获取 video。
    pub async fn retrieve(&self, video_id: &str) -> Result<Video, LingerError> {
        let video_id = validate_video_id(video_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/videos/{video_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Video>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Downloads generated video content with `GET /v1/videos/{video_id}/content`.
    /// 中文：使用 `GET /v1/videos/{video_id}/content` 下载生成的视频内容。
    pub async fn content(
        &self,
        video_id: &str,
        variant: Option<VideoContentVariant>,
    ) -> Result<VideoContent, LingerError> {
        let video_id = validate_video_id(video_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = if let Some(variant) = variant {
            format!(
                "/v1/videos/{video_id}/content?variant={}",
                variant.as_query_value()
            )
        } else {
            format!("/v1/videos/{video_id}/content")
        };
        let request = client.build_empty_request(HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        Ok(VideoContent::new(request_id, response.into_body_stream()))
    }

    /// EN: Deletes a video with `DELETE /v1/videos/{video_id}`.
    /// 中文：使用 `DELETE /v1/videos/{video_id}` 删除 video。
    pub async fn delete(&self, video_id: &str) -> Result<VideoDeletion, LingerError> {
        let video_id = validate_video_id(video_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/videos/{video_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VideoDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a remix with `POST /v1/videos/{video_id}/remix`.
    /// 中文：使用 `POST /v1/videos/{video_id}/remix` 创建 remix。
    pub async fn remix(
        &self,
        video_id: &str,
        request: CreateVideoRemixRequest,
    ) -> Result<Video, LingerError> {
        let video_id = validate_video_id(video_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/videos/{video_id}/remix");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Video>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Returns the Video Characters subresource.
    /// 中文：返回 Video Characters 子资源。
    pub fn characters(&self) -> VideoCharactersResource {
        VideoCharactersResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
        }
    }
}

/// EN: Video Characters API resource.
/// 中文：Video Characters API 资源。
#[derive(Clone, Debug)]
pub struct VideoCharactersResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl VideoCharactersResource {
    /// EN: Creates a video character with `POST /v1/videos/characters`.
    /// 中文：使用 `POST /v1/videos/characters` 创建 video character。
    pub async fn create(
        &self,
        request: CreateVideoCharacterRequest,
    ) -> Result<VideoCharacter, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request =
            client.build_empty_request(HttpMethod::Post, "/v1/videos/characters");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VideoCharacter>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a video character with `GET /v1/videos/characters/{character_id}`.
    /// 中文：使用 `GET /v1/videos/characters/{character_id}` 获取 video character。
    pub async fn retrieve(&self, character_id: &str) -> Result<VideoCharacter, LingerError> {
        let character_id = validate_video_character_id(character_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/videos/characters/{character_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<VideoCharacter>(&body)?.with_request_id(request_id);
        Ok(response)
    }
}

/// EN: Skills API resource.
/// 中文：Skills API 资源。
#[derive(Clone, Debug)]
pub struct SkillsResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl SkillsResource {
    /// EN: Creates a skill with `POST /v1/skills`.
    /// 中文：使用 `POST /v1/skills` 创建 skill。
    pub async fn create(&self, request: CreateSkillRequest) -> Result<Skill, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let mut http_request = client.build_empty_request(HttpMethod::Post, "/v1/skills");
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Skill>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists skills with `GET /v1/skills`.
    /// 中文：使用 `GET /v1/skills` 列出 skills。
    pub async fn list(&self) -> Result<SkillPage, LingerError> {
        self.list_with(SkillListRequest::default()).await
    }

    /// EN: Lists skills with query parameters for `GET /v1/skills`.
    /// 中文：使用查询参数调用 `GET /v1/skills` 列出 skills。
    pub async fn list_with(&self, request: SkillListRequest) -> Result<SkillPage, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path();
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<SkillPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a skill with `GET /v1/skills/{skill_id}`.
    /// 中文：使用 `GET /v1/skills/{skill_id}` 获取 skill。
    pub async fn retrieve(&self, skill_id: &str) -> Result<Skill, LingerError> {
        let skill_id = validate_skill_id(skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Skill>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Updates a skill default version with `POST /v1/skills/{skill_id}`.
    /// 中文：使用 `POST /v1/skills/{skill_id}` 更新 skill 默认版本。
    pub async fn update(
        &self,
        skill_id: &str,
        request: UpdateSkillRequest,
    ) -> Result<Skill, LingerError> {
        let skill_id = validate_skill_id(skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}");
        let request = client.build_json_request(HttpMethod::Post, &path, &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Skill>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a skill with `DELETE /v1/skills/{skill_id}`.
    /// 中文：使用 `DELETE /v1/skills/{skill_id}` 删除 skill。
    pub async fn delete(&self, skill_id: &str) -> Result<SkillDeletion, LingerError> {
        let skill_id = validate_skill_id(skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<SkillDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Downloads skill bundle content with `GET /v1/skills/{skill_id}/content`.
    /// 中文：使用 `GET /v1/skills/{skill_id}/content` 下载 skill bundle 内容。
    pub async fn content(&self, skill_id: &str) -> Result<SkillContent, LingerError> {
        let skill_id = validate_skill_id(skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}/content");
        let request = client.build_empty_request(HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        Ok(SkillContent::new(request_id, response.into_body_stream()))
    }

    /// EN: Returns the Skill Versions subresource for a skill id.
    /// 中文：返回指定 skill ID 的 Skill Versions 子资源。
    pub fn versions(&self, skill_id: &str) -> SkillVersionsResource {
        SkillVersionsResource {
            config: self.config.clone(),
            transport: self.transport.clone(),
            skill_id: skill_id.to_string(),
        }
    }
}

/// EN: Skill Versions API resource.
/// 中文：Skill Versions API 资源。
#[derive(Clone, Debug)]
pub struct SkillVersionsResource {
    config: ClientConfig,
    transport: SharedTransport,
    skill_id: String,
}

impl SkillVersionsResource {
    /// EN: Creates a skill version with `POST /v1/skills/{skill_id}/versions`.
    /// 中文：使用 `POST /v1/skills/{skill_id}/versions` 创建 skill version。
    pub async fn create(
        &self,
        request: CreateSkillVersionRequest,
    ) -> Result<SkillVersion, LingerError> {
        let skill_id = validate_skill_id(&self.skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}/versions");
        let mut http_request = client.build_empty_request(HttpMethod::Post, &path);
        request.apply_multipart_body(&mut http_request);
        let response = self.transport.send(http_request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<SkillVersion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists skill versions with `GET /v1/skills/{skill_id}/versions`.
    /// 中文：使用 `GET /v1/skills/{skill_id}/versions` 列出 skill versions。
    pub async fn list(&self) -> Result<SkillVersionPage, LingerError> {
        self.list_with(SkillVersionListRequest::default()).await
    }

    /// EN: Lists skill versions with query parameters for `GET /v1/skills/{skill_id}/versions`.
    /// 中文：使用查询参数调用 `GET /v1/skills/{skill_id}/versions` 列出 skill versions。
    pub async fn list_with(
        &self,
        request: SkillVersionListRequest,
    ) -> Result<SkillVersionPage, LingerError> {
        let skill_id = validate_skill_id(&self.skill_id)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = request.path(skill_id);
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<SkillVersionPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a skill version with `GET /v1/skills/{skill_id}/versions/{version}`.
    /// 中文：使用 `GET /v1/skills/{skill_id}/versions/{version}` 获取 skill version。
    pub async fn retrieve(&self, version: &str) -> Result<SkillVersion, LingerError> {
        let skill_id = validate_skill_id(&self.skill_id)?;
        let version = validate_skill_version(version)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}/versions/{version}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<SkillVersion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a skill version with `DELETE /v1/skills/{skill_id}/versions/{version}`.
    /// 中文：使用 `DELETE /v1/skills/{skill_id}/versions/{version}` 删除 skill version。
    pub async fn delete(&self, version: &str) -> Result<SkillVersionDeletion, LingerError> {
        let skill_id = validate_skill_id(&self.skill_id)?;
        let version = validate_skill_version(version)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}/versions/{version}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<SkillVersionDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Downloads skill version bundle content with `GET /v1/skills/{skill_id}/versions/{version}/content`.
    /// 中文：使用 `GET /v1/skills/{skill_id}/versions/{version}/content` 下载 skill version bundle 内容。
    pub async fn content(&self, version: &str) -> Result<SkillContent, LingerError> {
        let skill_id = validate_skill_id(&self.skill_id)?;
        let version = validate_skill_version(version)?;
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/skills/{skill_id}/versions/{version}/content");
        let request = client.build_empty_request(HttpMethod::Get, &path);
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(response.headers());
        Ok(SkillContent::new(request_id, response.into_body_stream()))
    }
}

/// EN: Responses API resource.
/// 中文：Responses API 资源。
#[derive(Clone, Debug)]
pub struct ResponsesResource {
    config: ClientConfig,
    transport: SharedTransport,
}

impl ResponsesResource {
    /// EN: Creates a response with `POST /v1/responses`.
    /// 中文：使用 `POST /v1/responses` 创建响应。
    pub async fn create(&self, request: CreateResponseRequest) -> Result<Response, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = client.build_json_request(HttpMethod::Post, "/v1/responses", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Response>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Retrieves a response with `GET /v1/responses/{response_id}`.
    /// 中文：使用 `GET /v1/responses/{response_id}` 获取响应。
    pub async fn retrieve(&self, response_id: &str) -> Result<Response, LingerError> {
        let response_id = response_id.trim();
        if response_id.is_empty() {
            return Err(LingerError::invalid_config("response_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/responses/{response_id}");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Response>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Cancels an in-progress response with `POST /v1/responses/{response_id}/cancel`.
    /// 中文：使用 `POST /v1/responses/{response_id}/cancel` 取消进行中的响应。
    pub async fn cancel(&self, response_id: &str) -> Result<Response, LingerError> {
        let response_id = response_id.trim();
        if response_id.is_empty() {
            return Err(LingerError::invalid_config("response_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/responses/{response_id}/cancel");
        let request = client.build_empty_request(HttpMethod::Post, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response = serde_json::from_slice::<Response>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Deletes a response with `DELETE /v1/responses/{response_id}`.
    /// 中文：使用 `DELETE /v1/responses/{response_id}` 删除响应。
    pub async fn delete(&self, response_id: &str) -> Result<ResponseDeletion, LingerError> {
        let response_id = response_id.trim();
        if response_id.is_empty() {
            return Err(LingerError::invalid_config("response_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/responses/{response_id}");
        let request = client.build_empty_request(HttpMethod::Delete, &path);
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ResponseDeletion>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Lists input items with `GET /v1/responses/{response_id}/input_items`.
    /// 中文：使用 `GET /v1/responses/{response_id}/input_items` 列出输入项。
    pub async fn list_input_items(
        &self,
        response_id: &str,
    ) -> Result<ResponseInputItemsPage, LingerError> {
        let response_id = response_id.trim();
        if response_id.is_empty() {
            return Err(LingerError::invalid_config("response_id is required"));
        }
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let path = format!("/v1/responses/{response_id}/input_items");
        let (headers, body) = client.send_retryable_get(&path).await?;
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ResponseInputItemsPage>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Counts input tokens with `POST /v1/responses/input_tokens`.
    /// 中文：使用 `POST /v1/responses/input_tokens` 统计输入 token。
    pub async fn count_input_tokens(
        &self,
        request: CreateResponseInputTokensRequest,
    ) -> Result<ResponseInputTokens, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/responses/input_tokens", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ResponseInputTokens>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Compacts response context with `POST /v1/responses/compact`.
    /// 中文：使用 `POST /v1/responses/compact` 压缩响应上下文。
    pub async fn compact(
        &self,
        request: CompactResponseRequest,
    ) -> Result<ResponseCompaction, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request =
            client.build_json_request(HttpMethod::Post, "/v1/responses/compact", &request)?;
        let response = self.transport.send(request).await?;
        let (status, headers, body) = response.into_bytes().await?;
        if !(200..300).contains(&status) {
            return Err(parse_api_error(status, headers, &body));
        }
        let request_id = request_id_from_headers(&headers);
        let response =
            serde_json::from_slice::<ResponseCompaction>(&body)?.with_request_id(request_id);
        Ok(response)
    }

    /// EN: Creates a streaming response with `POST /v1/responses`.
    /// 中文：使用 `POST /v1/responses` 创建流式响应。
    pub async fn create_stream(
        &self,
        request: CreateResponseRequest,
    ) -> Result<ResponseStream, LingerError> {
        let client = Client {
            config: self.config.clone(),
            transport: self.transport.clone(),
        };
        let request = request.into_streaming();
        let request = client.build_json_request(HttpMethod::Post, "/v1/responses", &request)?;
        let response = self.transport.send(request).await?;
        let status = response.status();
        if !(200..300).contains(&status) {
            let (status, headers, body) = response.into_bytes().await?;
            return Err(parse_api_error(status, headers, &body));
        }
        Ok(ResponseStream::new(response.into_body_stream()))
    }
}

fn apply_auth_headers(request: &mut HttpRequest, config: &ClientConfig) {
    request.insert_header("authorization", format!("Bearer {}", config.api_key()));
    if let Some(organization) = config.organization() {
        request.insert_header("openai-organization", organization);
    }
    if let Some(project) = config.project() {
        request.insert_header("openai-project", project);
    }
}

fn apply_assistants_beta_header(request: &mut HttpRequest) {
    request.insert_header("openai-beta", "assistants=v2");
}

fn apply_chatkit_beta_header(request: &mut HttpRequest) {
    request.insert_header("openai-beta", "chatkit_beta=v1");
}

fn validate_fine_tuning_job_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config(
            "fine_tuning_job_id is required",
        ));
    }
    Ok(value)
}

fn validate_fine_tuned_model_checkpoint(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config(
            "fine_tuned_model_checkpoint is required",
        ));
    }
    Ok(value)
}

fn validate_checkpoint_permission_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("permission_id is required"));
    }
    Ok(value)
}

fn validate_upload_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("upload_id is required"));
    }
    Ok(value)
}

fn validate_vector_store_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("vector_store_id is required"));
    }
    Ok(value)
}

fn validate_container_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("container_id is required"));
    }
    Ok(value)
}

fn validate_container_file_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("container_file_id is required"));
    }
    Ok(value)
}

fn validate_voice_consent_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("voice_consent_id is required"));
    }
    Ok(value)
}

fn validate_eval_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("eval_id is required"));
    }
    Ok(value)
}

fn validate_eval_run_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("run_id is required"));
    }
    Ok(value)
}

fn validate_eval_run_output_item_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("output_item_id is required"));
    }
    Ok(value)
}

fn validate_conversation_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("conversation_id is required"));
    }
    Ok(value)
}

fn validate_conversation_item_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config(
            "conversation_item_id is required",
        ));
    }
    Ok(value)
}

fn validate_file_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("file_id is required"));
    }
    Ok(value)
}

fn validate_chat_completion_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("completion_id is required"));
    }
    Ok(value)
}

fn validate_chatkit_session_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("session_id is required"));
    }
    Ok(value)
}

fn validate_chatkit_thread_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("thread_id is required"));
    }
    Ok(value)
}

fn validate_realtime_call_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("call_id is required"));
    }
    Ok(value)
}

fn validate_batch_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("batch_id is required"));
    }
    Ok(value)
}

fn validate_video_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("video_id is required"));
    }
    Ok(value)
}

fn validate_video_character_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("character_id is required"));
    }
    Ok(value)
}

fn validate_skill_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("skill_id is required"));
    }
    Ok(value)
}

fn validate_skill_version(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("version is required"));
    }
    Ok(value)
}

fn validate_assistant_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("assistant_id is required"));
    }
    Ok(value)
}

fn validate_thread_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("thread_id is required"));
    }
    Ok(value)
}

fn validate_message_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("message_id is required"));
    }
    Ok(value)
}

fn validate_run_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("run_id is required"));
    }
    Ok(value)
}

fn validate_step_id(value: &str) -> Result<&str, LingerError> {
    let value = value.trim();
    if value.is_empty() {
        return Err(LingerError::invalid_config("step_id is required"));
    }
    Ok(value)
}