openai_api_rs/v1/
api.rs

1use crate::v1::assistant::{
2    AssistantFileObject, AssistantFileRequest, AssistantObject, AssistantRequest, ListAssistant,
3    ListAssistantFile,
4};
5use crate::v1::audio::{
6    AudioSpeechRequest, AudioSpeechResponse, AudioTranscriptionRequest, AudioTranscriptionResponse,
7    AudioTranslationRequest, AudioTranslationResponse,
8};
9use crate::v1::batch::{BatchResponse, CreateBatchRequest, ListBatchResponse};
10use crate::v1::chat_completion::{ChatCompletionRequest, ChatCompletionResponse};
11use crate::v1::common;
12use crate::v1::completion::{CompletionRequest, CompletionResponse};
13use crate::v1::edit::{EditRequest, EditResponse};
14use crate::v1::embedding::{EmbeddingRequest, EmbeddingResponse};
15use crate::v1::error::APIError;
16use crate::v1::file::{
17    FileDeleteRequest, FileDeleteResponse, FileListResponse, FileRetrieveResponse,
18    FileUploadRequest, FileUploadResponse,
19};
20use crate::v1::fine_tuning::{
21    CancelFineTuningJobRequest, CreateFineTuningJobRequest, FineTuningJobEvent,
22    FineTuningJobObject, FineTuningPagination, ListFineTuningJobEventsRequest,
23    RetrieveFineTuningJobRequest,
24};
25use crate::v1::image::{
26    ImageEditRequest, ImageEditResponse, ImageGenerationRequest, ImageGenerationResponse,
27    ImageVariationRequest, ImageVariationResponse,
28};
29use crate::v1::message::{
30    CreateMessageRequest, ListMessage, ListMessageFile, MessageFileObject, MessageObject,
31    ModifyMessageRequest,
32};
33use crate::v1::model::{ModelResponse, ModelsResponse};
34use crate::v1::moderation::{CreateModerationRequest, CreateModerationResponse};
35use crate::v1::run::{
36    CreateRunRequest, CreateThreadAndRunRequest, ListRun, ListRunStep, ModifyRunRequest, RunObject,
37    RunStepObject,
38};
39use crate::v1::thread::{CreateThreadRequest, ModifyThreadRequest, ThreadObject};
40
41use bytes::Bytes;
42use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
43use reqwest::multipart::{Form, Part};
44use reqwest::{Client, Method, Response};
45use serde::Serialize;
46use serde_json::Value;
47use url::Url;
48
49use std::error::Error;
50use std::fs::{create_dir_all, File};
51use std::io::Read;
52use std::io::Write;
53use std::path::Path;
54
55const API_URL_V1: &str = "https://api.openai.com/v1";
56
57#[derive(Default)]
58pub struct OpenAIClientBuilder {
59    api_endpoint: Option<String>,
60    api_key: Option<String>,
61    organization: Option<String>,
62    proxy: Option<String>,
63    timeout: Option<u64>,
64    headers: Option<HeaderMap>,
65}
66
67#[derive(Debug)]
68pub struct OpenAIClient {
69    api_endpoint: String,
70    api_key: Option<String>,
71    organization: Option<String>,
72    proxy: Option<String>,
73    timeout: Option<u64>,
74    headers: Option<HeaderMap>,
75    pub response_headers: Option<HeaderMap>,
76}
77
78impl OpenAIClientBuilder {
79    pub fn new() -> Self {
80        Self::default()
81    }
82
83    pub fn with_api_key(mut self, api_key: impl Into<String>) -> Self {
84        self.api_key = Some(api_key.into());
85        self
86    }
87
88    pub fn with_endpoint(mut self, endpoint: impl Into<String>) -> Self {
89        self.api_endpoint = Some(endpoint.into());
90        self
91    }
92
93    pub fn with_organization(mut self, organization: impl Into<String>) -> Self {
94        self.organization = Some(organization.into());
95        self
96    }
97
98    pub fn with_proxy(mut self, proxy: impl Into<String>) -> Self {
99        self.proxy = Some(proxy.into());
100        self
101    }
102
103    pub fn with_timeout(mut self, timeout: u64) -> Self {
104        self.timeout = Some(timeout);
105        self
106    }
107
108    pub fn with_header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
109        let headers = self.headers.get_or_insert_with(HeaderMap::new);
110        headers.insert(
111            HeaderName::from_bytes(key.into().as_bytes()).expect("Invalid header name"),
112            HeaderValue::from_str(&value.into()).expect("Invalid header value"),
113        );
114        self
115    }
116
117    pub fn build(self) -> Result<OpenAIClient, Box<dyn Error>> {
118        let api_endpoint = self.api_endpoint.unwrap_or_else(|| {
119            std::env::var("OPENAI_API_BASE").unwrap_or_else(|_| API_URL_V1.to_owned())
120        });
121
122        Ok(OpenAIClient {
123            api_endpoint,
124            api_key: self.api_key,
125            organization: self.organization,
126            proxy: self.proxy,
127            timeout: self.timeout,
128            headers: self.headers,
129            response_headers: None,
130        })
131    }
132}
133
134impl OpenAIClient {
135    pub fn builder() -> OpenAIClientBuilder {
136        OpenAIClientBuilder::new()
137    }
138
139    async fn build_request(&self, method: Method, path: &str) -> reqwest::RequestBuilder {
140        let url = self
141            .build_url_with_preserved_query(path)
142            .unwrap_or_else(|_| format!("{}/{}", self.api_endpoint, path));
143
144        let client = Client::builder();
145
146        #[cfg(feature = "rustls")]
147        let client = client.use_rustls_tls();
148
149        let client = if let Some(timeout) = self.timeout {
150            client.timeout(std::time::Duration::from_secs(timeout))
151        } else {
152            client
153        };
154
155        let client = if let Some(proxy) = &self.proxy {
156            client.proxy(reqwest::Proxy::all(proxy).unwrap())
157        } else {
158            client
159        };
160
161        let client = client.build().unwrap();
162
163        let mut request = client.request(method, url);
164
165        if let Some(api_key) = &self.api_key {
166            request = request.header("Authorization", format!("Bearer {}", api_key));
167        }
168
169        if let Some(organization) = &self.organization {
170            request = request.header("openai-organization", organization);
171        }
172
173        if let Some(headers) = &self.headers {
174            for (key, value) in headers {
175                request = request.header(key, value);
176            }
177        }
178
179        if Self::is_beta(path) {
180            request = request.header("OpenAI-Beta", "assistants=v2");
181        }
182
183        request
184    }
185
186    async fn post<T: serde::de::DeserializeOwned>(
187        &mut self,
188        path: &str,
189        body: &impl serde::ser::Serialize,
190    ) -> Result<T, APIError> {
191        let request = self.build_request(Method::POST, path).await;
192        let request = request.json(body);
193        let response = request.send().await?;
194        self.handle_response(response).await
195    }
196
197    async fn get<T: serde::de::DeserializeOwned>(&mut self, path: &str) -> Result<T, APIError> {
198        let request = self.build_request(Method::GET, path).await;
199        let response = request.send().await?;
200        self.handle_response(response).await
201    }
202
203    async fn get_raw(&self, path: &str) -> Result<Bytes, APIError> {
204        let request = self.build_request(Method::GET, path).await;
205        let response = request.send().await?;
206        Ok(response.bytes().await?)
207    }
208
209    async fn delete<T: serde::de::DeserializeOwned>(&mut self, path: &str) -> Result<T, APIError> {
210        let request = self.build_request(Method::DELETE, path).await;
211        let response = request.send().await?;
212        self.handle_response(response).await
213    }
214
215    async fn post_form<T: serde::de::DeserializeOwned>(
216        &mut self,
217        path: &str,
218        form: Form,
219    ) -> Result<T, APIError> {
220        let request = self.build_request(Method::POST, path).await;
221        let request = request.multipart(form);
222        let response = request.send().await?;
223        self.handle_response(response).await
224    }
225
226    async fn post_form_raw(&self, path: &str, form: Form) -> Result<Bytes, APIError> {
227        let request = self.build_request(Method::POST, path).await;
228        let request = request.multipart(form);
229        let response = request.send().await?;
230        Ok(response.bytes().await?)
231    }
232
233    async fn handle_response<T: serde::de::DeserializeOwned>(
234        &mut self,
235        response: Response,
236    ) -> Result<T, APIError> {
237        let status = response.status();
238        let headers = response.headers().clone();
239        if status.is_success() {
240            let text = response.text().await.unwrap_or_else(|_| "".to_string());
241            match serde_json::from_str::<T>(&text) {
242                Ok(parsed) => {
243                    self.response_headers = Some(headers);
244                    Ok(parsed)
245                }
246                Err(e) => Err(APIError::CustomError {
247                    message: format!("Failed to parse JSON: {} / response {}", e, text),
248                }),
249            }
250        } else {
251            let error_message = response
252                .text()
253                .await
254                .unwrap_or_else(|_| "Unknown error".to_string());
255            Err(APIError::CustomError {
256                message: format!("{}: {}", status, error_message),
257            })
258        }
259    }
260
261    pub async fn completion(
262        &mut self,
263        req: CompletionRequest,
264    ) -> Result<CompletionResponse, APIError> {
265        self.post("completions", &req).await
266    }
267
268    pub async fn edit(&mut self, req: EditRequest) -> Result<EditResponse, APIError> {
269        self.post("edits", &req).await
270    }
271
272    pub async fn image_generation(
273        &mut self,
274        req: ImageGenerationRequest,
275    ) -> Result<ImageGenerationResponse, APIError> {
276        self.post("images/generations", &req).await
277    }
278
279    pub async fn image_edit(
280        &mut self,
281        req: ImageEditRequest,
282    ) -> Result<ImageEditResponse, APIError> {
283        self.post("images/edits", &req).await
284    }
285
286    pub async fn image_variation(
287        &mut self,
288        req: ImageVariationRequest,
289    ) -> Result<ImageVariationResponse, APIError> {
290        self.post("images/variations", &req).await
291    }
292
293    pub async fn embedding(
294        &mut self,
295        req: EmbeddingRequest,
296    ) -> Result<EmbeddingResponse, APIError> {
297        self.post("embeddings", &req).await
298    }
299
300    pub async fn file_list(&mut self) -> Result<FileListResponse, APIError> {
301        self.get("files").await
302    }
303
304    pub async fn upload_file(
305        &mut self,
306        req: FileUploadRequest,
307    ) -> Result<FileUploadResponse, APIError> {
308        let form = Self::create_form(&req, "file")?;
309        self.post_form("files", form).await
310    }
311
312    pub async fn delete_file(
313        &mut self,
314        req: FileDeleteRequest,
315    ) -> Result<FileDeleteResponse, APIError> {
316        self.delete(&format!("files/{}", req.file_id)).await
317    }
318
319    pub async fn retrieve_file(
320        &mut self,
321        file_id: String,
322    ) -> Result<FileRetrieveResponse, APIError> {
323        self.get(&format!("files/{}", file_id)).await
324    }
325
326    pub async fn retrieve_file_content(&self, file_id: String) -> Result<Bytes, APIError> {
327        self.get_raw(&format!("files/{}/content", file_id)).await
328    }
329
330    pub async fn chat_completion(
331        &mut self,
332        req: ChatCompletionRequest,
333    ) -> Result<ChatCompletionResponse, APIError> {
334        self.post("chat/completions", &req).await
335    }
336
337    pub async fn audio_transcription(
338        &mut self,
339        req: AudioTranscriptionRequest,
340    ) -> Result<AudioTranscriptionResponse, APIError> {
341        // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-response_format
342        if let Some(response_format) = &req.response_format {
343            if response_format != "json" && response_format != "verbose_json" {
344                return Err(APIError::CustomError {
345                    message: "response_format must be either 'json' or 'verbose_json' please use audio_transcription_raw".to_string(),
346                });
347            }
348        }
349        let form: Form;
350        if req.clone().file.is_some() {
351            form = Self::create_form(&req, "file")?;
352        } else if let Some(bytes) = req.clone().bytes {
353            form = Self::create_form_from_bytes(&req, bytes)?;
354        } else {
355            return Err(APIError::CustomError {
356                message: "Either file or bytes must be provided".to_string(),
357            });
358        }
359        self.post_form("audio/transcriptions", form).await
360    }
361
362    pub async fn audio_transcription_raw(
363        &mut self,
364        req: AudioTranscriptionRequest,
365    ) -> Result<Bytes, APIError> {
366        // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-response_format
367        if let Some(response_format) = &req.response_format {
368            if response_format != "text" && response_format != "srt" && response_format != "vtt" {
369                return Err(APIError::CustomError {
370                    message: "response_format must be either 'text', 'srt' or 'vtt', please use audio_transcription".to_string(),
371                });
372            }
373        }
374        let form: Form;
375        if req.clone().file.is_some() {
376            form = Self::create_form(&req, "file")?;
377        } else if let Some(bytes) = req.clone().bytes {
378            form = Self::create_form_from_bytes(&req, bytes)?;
379        } else {
380            return Err(APIError::CustomError {
381                message: "Either file or bytes must be provided".to_string(),
382            });
383        }
384        self.post_form_raw("audio/transcriptions", form).await
385    }
386
387    pub async fn audio_translation(
388        &mut self,
389        req: AudioTranslationRequest,
390    ) -> Result<AudioTranslationResponse, APIError> {
391        let form = Self::create_form(&req, "file")?;
392        self.post_form("audio/translations", form).await
393    }
394
395    pub async fn audio_speech(
396        &mut self,
397        req: AudioSpeechRequest,
398    ) -> Result<AudioSpeechResponse, APIError> {
399        let request = self.build_request(Method::POST, "audio/speech").await;
400        let request = request.json(&req);
401        let response = request.send().await?;
402        let headers = response.headers().clone();
403        let bytes = response.bytes().await?;
404        let path = Path::new(req.output.as_str());
405        if let Some(parent) = path.parent() {
406            match create_dir_all(parent) {
407                Ok(_) => {}
408                Err(e) => {
409                    return Err(APIError::CustomError {
410                        message: e.to_string(),
411                    })
412                }
413            }
414        }
415        match File::create(path) {
416            Ok(mut file) => match file.write_all(&bytes) {
417                Ok(_) => {}
418                Err(e) => {
419                    return Err(APIError::CustomError {
420                        message: e.to_string(),
421                    })
422                }
423            },
424            Err(e) => {
425                return Err(APIError::CustomError {
426                    message: e.to_string(),
427                })
428            }
429        }
430
431        Ok(AudioSpeechResponse {
432            result: true,
433            headers: Some(headers),
434        })
435    }
436
437    pub async fn create_fine_tuning_job(
438        &mut self,
439        req: CreateFineTuningJobRequest,
440    ) -> Result<FineTuningJobObject, APIError> {
441        self.post("fine_tuning/jobs", &req).await
442    }
443
444    pub async fn list_fine_tuning_jobs(
445        &mut self,
446    ) -> Result<FineTuningPagination<FineTuningJobObject>, APIError> {
447        self.get("fine_tuning/jobs").await
448    }
449
450    pub async fn list_fine_tuning_job_events(
451        &mut self,
452        req: ListFineTuningJobEventsRequest,
453    ) -> Result<FineTuningPagination<FineTuningJobEvent>, APIError> {
454        self.get(&format!(
455            "fine_tuning/jobs/{}/events",
456            req.fine_tuning_job_id
457        ))
458        .await
459    }
460
461    pub async fn retrieve_fine_tuning_job(
462        &mut self,
463        req: RetrieveFineTuningJobRequest,
464    ) -> Result<FineTuningJobObject, APIError> {
465        self.get(&format!("fine_tuning/jobs/{}", req.fine_tuning_job_id))
466            .await
467    }
468
469    pub async fn cancel_fine_tuning_job(
470        &mut self,
471        req: CancelFineTuningJobRequest,
472    ) -> Result<FineTuningJobObject, APIError> {
473        self.post(
474            &format!("fine_tuning/jobs/{}/cancel", req.fine_tuning_job_id),
475            &req,
476        )
477        .await
478    }
479
480    pub async fn create_moderation(
481        &mut self,
482        req: CreateModerationRequest,
483    ) -> Result<CreateModerationResponse, APIError> {
484        self.post("moderations", &req).await
485    }
486
487    pub async fn create_assistant(
488        &mut self,
489        req: AssistantRequest,
490    ) -> Result<AssistantObject, APIError> {
491        self.post("assistants", &req).await
492    }
493
494    pub async fn retrieve_assistant(
495        &mut self,
496        assistant_id: String,
497    ) -> Result<AssistantObject, APIError> {
498        self.get(&format!("assistants/{}", assistant_id)).await
499    }
500
501    pub async fn modify_assistant(
502        &mut self,
503        assistant_id: String,
504        req: AssistantRequest,
505    ) -> Result<AssistantObject, APIError> {
506        self.post(&format!("assistants/{}", assistant_id), &req)
507            .await
508    }
509
510    pub async fn delete_assistant(
511        &mut self,
512        assistant_id: String,
513    ) -> Result<common::DeletionStatus, APIError> {
514        self.delete(&format!("assistants/{}", assistant_id)).await
515    }
516
517    pub async fn list_assistant(
518        &mut self,
519        limit: Option<i64>,
520        order: Option<String>,
521        after: Option<String>,
522        before: Option<String>,
523    ) -> Result<ListAssistant, APIError> {
524        let url = Self::query_params(limit, order, after, before, "assistants".to_string());
525        self.get(&url).await
526    }
527
528    pub async fn create_assistant_file(
529        &mut self,
530        assistant_id: String,
531        req: AssistantFileRequest,
532    ) -> Result<AssistantFileObject, APIError> {
533        self.post(&format!("assistants/{}/files", assistant_id), &req)
534            .await
535    }
536
537    pub async fn retrieve_assistant_file(
538        &mut self,
539        assistant_id: String,
540        file_id: String,
541    ) -> Result<AssistantFileObject, APIError> {
542        self.get(&format!("assistants/{}/files/{}", assistant_id, file_id))
543            .await
544    }
545
546    pub async fn delete_assistant_file(
547        &mut self,
548        assistant_id: String,
549        file_id: String,
550    ) -> Result<common::DeletionStatus, APIError> {
551        self.delete(&format!("assistants/{}/files/{}", assistant_id, file_id))
552            .await
553    }
554
555    pub async fn list_assistant_file(
556        &mut self,
557        assistant_id: String,
558        limit: Option<i64>,
559        order: Option<String>,
560        after: Option<String>,
561        before: Option<String>,
562    ) -> Result<ListAssistantFile, APIError> {
563        let url = Self::query_params(
564            limit,
565            order,
566            after,
567            before,
568            format!("assistants/{}/files", assistant_id),
569        );
570        self.get(&url).await
571    }
572
573    pub async fn create_thread(
574        &mut self,
575        req: CreateThreadRequest,
576    ) -> Result<ThreadObject, APIError> {
577        self.post("threads", &req).await
578    }
579
580    pub async fn retrieve_thread(&mut self, thread_id: String) -> Result<ThreadObject, APIError> {
581        self.get(&format!("threads/{}", thread_id)).await
582    }
583
584    pub async fn modify_thread(
585        &mut self,
586        thread_id: String,
587        req: ModifyThreadRequest,
588    ) -> Result<ThreadObject, APIError> {
589        self.post(&format!("threads/{}", thread_id), &req).await
590    }
591
592    pub async fn delete_thread(
593        &mut self,
594        thread_id: String,
595    ) -> Result<common::DeletionStatus, APIError> {
596        self.delete(&format!("threads/{}", thread_id)).await
597    }
598
599    pub async fn create_message(
600        &mut self,
601        thread_id: String,
602        req: CreateMessageRequest,
603    ) -> Result<MessageObject, APIError> {
604        self.post(&format!("threads/{}/messages", thread_id), &req)
605            .await
606    }
607
608    pub async fn retrieve_message(
609        &mut self,
610        thread_id: String,
611        message_id: String,
612    ) -> Result<MessageObject, APIError> {
613        self.get(&format!("threads/{}/messages/{}", thread_id, message_id))
614            .await
615    }
616
617    pub async fn modify_message(
618        &mut self,
619        thread_id: String,
620        message_id: String,
621        req: ModifyMessageRequest,
622    ) -> Result<MessageObject, APIError> {
623        self.post(
624            &format!("threads/{}/messages/{}", thread_id, message_id),
625            &req,
626        )
627        .await
628    }
629
630    pub async fn list_messages(&mut self, thread_id: String) -> Result<ListMessage, APIError> {
631        self.get(&format!("threads/{}/messages", thread_id)).await
632    }
633
634    pub async fn retrieve_message_file(
635        &mut self,
636        thread_id: String,
637        message_id: String,
638        file_id: String,
639    ) -> Result<MessageFileObject, APIError> {
640        self.get(&format!(
641            "threads/{}/messages/{}/files/{}",
642            thread_id, message_id, file_id
643        ))
644        .await
645    }
646
647    pub async fn list_message_file(
648        &mut self,
649        thread_id: String,
650        message_id: String,
651        limit: Option<i64>,
652        order: Option<String>,
653        after: Option<String>,
654        before: Option<String>,
655    ) -> Result<ListMessageFile, APIError> {
656        let url = Self::query_params(
657            limit,
658            order,
659            after,
660            before,
661            format!("threads/{}/messages/{}/files", thread_id, message_id),
662        );
663        self.get(&url).await
664    }
665
666    pub async fn create_run(
667        &mut self,
668        thread_id: String,
669        req: CreateRunRequest,
670    ) -> Result<RunObject, APIError> {
671        self.post(&format!("threads/{}/runs", thread_id), &req)
672            .await
673    }
674
675    pub async fn retrieve_run(
676        &mut self,
677        thread_id: String,
678        run_id: String,
679    ) -> Result<RunObject, APIError> {
680        self.get(&format!("threads/{}/runs/{}", thread_id, run_id))
681            .await
682    }
683
684    pub async fn modify_run(
685        &mut self,
686        thread_id: String,
687        run_id: String,
688        req: ModifyRunRequest,
689    ) -> Result<RunObject, APIError> {
690        self.post(&format!("threads/{}/runs/{}", thread_id, run_id), &req)
691            .await
692    }
693
694    pub async fn list_run(
695        &mut self,
696        thread_id: String,
697        limit: Option<i64>,
698        order: Option<String>,
699        after: Option<String>,
700        before: Option<String>,
701    ) -> Result<ListRun, APIError> {
702        let url = Self::query_params(
703            limit,
704            order,
705            after,
706            before,
707            format!("threads/{}/runs", thread_id),
708        );
709        self.get(&url).await
710    }
711
712    pub async fn cancel_run(
713        &mut self,
714        thread_id: String,
715        run_id: String,
716    ) -> Result<RunObject, APIError> {
717        self.post(
718            &format!("threads/{}/runs/{}/cancel", thread_id, run_id),
719            &ModifyRunRequest::default(),
720        )
721        .await
722    }
723
724    pub async fn create_thread_and_run(
725        &mut self,
726        req: CreateThreadAndRunRequest,
727    ) -> Result<RunObject, APIError> {
728        self.post("threads/runs", &req).await
729    }
730
731    pub async fn retrieve_run_step(
732        &mut self,
733        thread_id: String,
734        run_id: String,
735        step_id: String,
736    ) -> Result<RunStepObject, APIError> {
737        self.get(&format!(
738            "threads/{}/runs/{}/steps/{}",
739            thread_id, run_id, step_id
740        ))
741        .await
742    }
743
744    pub async fn list_run_step(
745        &mut self,
746        thread_id: String,
747        run_id: String,
748        limit: Option<i64>,
749        order: Option<String>,
750        after: Option<String>,
751        before: Option<String>,
752    ) -> Result<ListRunStep, APIError> {
753        let url = Self::query_params(
754            limit,
755            order,
756            after,
757            before,
758            format!("threads/{}/runs/{}/steps", thread_id, run_id),
759        );
760        self.get(&url).await
761    }
762
763    pub async fn create_batch(
764        &mut self,
765        req: CreateBatchRequest,
766    ) -> Result<BatchResponse, APIError> {
767        self.post("batches", &req).await
768    }
769
770    pub async fn retrieve_batch(&mut self, batch_id: String) -> Result<BatchResponse, APIError> {
771        self.get(&format!("batches/{}", batch_id)).await
772    }
773
774    pub async fn cancel_batch(&mut self, batch_id: String) -> Result<BatchResponse, APIError> {
775        self.post(
776            &format!("batches/{}/cancel", batch_id),
777            &common::EmptyRequestBody {},
778        )
779        .await
780    }
781
782    pub async fn list_batch(
783        &mut self,
784        after: Option<String>,
785        limit: Option<i64>,
786    ) -> Result<ListBatchResponse, APIError> {
787        let url = Self::query_params(limit, None, after, None, "batches".to_string());
788        self.get(&url).await
789    }
790
791    pub async fn list_models(&mut self) -> Result<ModelsResponse, APIError> {
792        self.get("models").await
793    }
794
795    pub async fn retrieve_model(&mut self, model_id: String) -> Result<ModelResponse, APIError> {
796        self.get(&format!("models/{}", model_id)).await
797    }
798
799    pub async fn delete_model(
800        &mut self,
801        model_id: String,
802    ) -> Result<common::DeletionStatus, APIError> {
803        self.delete(&format!("models/{}", model_id)).await
804    }
805
806    fn build_url_with_preserved_query(&self, path: &str) -> Result<String, url::ParseError> {
807        let (base, query_opt) = match self.api_endpoint.split_once('?') {
808            Some((b, q)) => (b.trim_end_matches('/'), Some(q)),
809            None => (self.api_endpoint.trim_end_matches('/'), None),
810        };
811
812        let full_path = format!("{}/{}", base, path.trim_start_matches('/'));
813        let mut url = Url::parse(&full_path)?;
814
815        if let Some(query) = query_opt {
816            for (k, v) in url::form_urlencoded::parse(query.as_bytes()) {
817                url.query_pairs_mut().append_pair(&k, &v);
818            }
819        }
820        Ok(url.to_string())
821    }
822
823    fn query_params(
824        limit: Option<i64>,
825        order: Option<String>,
826        after: Option<String>,
827        before: Option<String>,
828        mut url: String,
829    ) -> String {
830        let mut params = vec![];
831        if let Some(limit) = limit {
832            params.push(format!("limit={}", limit));
833        }
834        if let Some(order) = order {
835            params.push(format!("order={}", order));
836        }
837        if let Some(after) = after {
838            params.push(format!("after={}", after));
839        }
840        if let Some(before) = before {
841            params.push(format!("before={}", before));
842        }
843        if !params.is_empty() {
844            url = format!("{}?{}", url, params.join("&"));
845        }
846        url
847    }
848
849    fn is_beta(path: &str) -> bool {
850        path.starts_with("assistants") || path.starts_with("threads")
851    }
852
853    fn create_form<T>(req: &T, file_field: &str) -> Result<Form, APIError>
854    where
855        T: Serialize,
856    {
857        let json = match serde_json::to_value(req) {
858            Ok(json) => json,
859            Err(e) => {
860                return Err(APIError::CustomError {
861                    message: e.to_string(),
862                })
863            }
864        };
865        let file_path = if let Value::Object(map) = &json {
866            map.get(file_field)
867                .and_then(|v| v.as_str())
868                .ok_or(APIError::CustomError {
869                    message: format!("Field '{}' not found or not a string", file_field),
870                })?
871        } else {
872            return Err(APIError::CustomError {
873                message: "Request is not a JSON object".to_string(),
874            });
875        };
876
877        let mut file = match File::open(file_path) {
878            Ok(file) => file,
879            Err(e) => {
880                return Err(APIError::CustomError {
881                    message: e.to_string(),
882                })
883            }
884        };
885        let mut buffer = Vec::new();
886        match file.read_to_end(&mut buffer) {
887            Ok(_) => {}
888            Err(e) => {
889                return Err(APIError::CustomError {
890                    message: e.to_string(),
891                })
892            }
893        }
894
895        let mut form =
896            Form::new().part("file", Part::bytes(buffer).file_name(file_path.to_string()));
897
898        if let Value::Object(map) = json {
899            for (key, value) in map.into_iter() {
900                if key != file_field {
901                    match value {
902                        Value::String(s) => {
903                            form = form.text(key, s);
904                        }
905                        Value::Number(n) => {
906                            form = form.text(key, n.to_string());
907                        }
908                        _ => {}
909                    }
910                }
911            }
912        }
913
914        Ok(form)
915    }
916
917    fn create_form_from_bytes<T>(req: &T, bytes: Vec<u8>) -> Result<Form, APIError>
918    where
919        T: Serialize,
920    {
921        let json = match serde_json::to_value(req) {
922            Ok(json) => json,
923            Err(e) => {
924                return Err(APIError::CustomError {
925                    message: e.to_string(),
926                })
927            }
928        };
929
930        let mut form = Form::new().part("file", Part::bytes(bytes.clone()).file_name("file.mp3"));
931
932        if let Value::Object(map) = json {
933            for (key, value) in map.into_iter() {
934                match value {
935                    Value::String(s) => {
936                        form = form.text(key, s);
937                    }
938                    Value::Number(n) => {
939                        form = form.text(key, n.to_string());
940                    }
941                    _ => {}
942                }
943            }
944        }
945
946        Ok(form)
947    }
948}
openai_api_rs/v1/api.rs

openai_api_rs/v1/
api.rs
