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: {e} / response {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/{file_id}/content")).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).await
507    }
508
509    pub async fn delete_assistant(
510        &mut self,
511        assistant_id: String,
512    ) -> Result<common::DeletionStatus, APIError> {
513        self.delete(&format!("assistants/{assistant_id}")).await
514    }
515
516    pub async fn list_assistant(
517        &mut self,
518        limit: Option<i64>,
519        order: Option<String>,
520        after: Option<String>,
521        before: Option<String>,
522    ) -> Result<ListAssistant, APIError> {
523        let url = Self::query_params(limit, order, after, before, "assistants".to_string());
524        self.get(&url).await
525    }
526
527    pub async fn create_assistant_file(
528        &mut self,
529        assistant_id: String,
530        req: AssistantFileRequest,
531    ) -> Result<AssistantFileObject, APIError> {
532        self.post(&format!("assistants/{assistant_id}/files"), &req)
533            .await
534    }
535
536    pub async fn retrieve_assistant_file(
537        &mut self,
538        assistant_id: String,
539        file_id: String,
540    ) -> Result<AssistantFileObject, APIError> {
541        self.get(&format!("assistants/{assistant_id}/files/{file_id}"))
542            .await
543    }
544
545    pub async fn delete_assistant_file(
546        &mut self,
547        assistant_id: String,
548        file_id: String,
549    ) -> Result<common::DeletionStatus, APIError> {
550        self.delete(&format!("assistants/{assistant_id}/files/{file_id}"))
551            .await
552    }
553
554    pub async fn list_assistant_file(
555        &mut self,
556        assistant_id: String,
557        limit: Option<i64>,
558        order: Option<String>,
559        after: Option<String>,
560        before: Option<String>,
561    ) -> Result<ListAssistantFile, APIError> {
562        let url = Self::query_params(
563            limit,
564            order,
565            after,
566            before,
567            format!("assistants/{assistant_id}/files"),
568        );
569        self.get(&url).await
570    }
571
572    pub async fn create_thread(
573        &mut self,
574        req: CreateThreadRequest,
575    ) -> Result<ThreadObject, APIError> {
576        self.post("threads", &req).await
577    }
578
579    pub async fn retrieve_thread(&mut self, thread_id: String) -> Result<ThreadObject, APIError> {
580        self.get(&format!("threads/{thread_id}")).await
581    }
582
583    pub async fn modify_thread(
584        &mut self,
585        thread_id: String,
586        req: ModifyThreadRequest,
587    ) -> Result<ThreadObject, APIError> {
588        self.post(&format!("threads/{thread_id}"), &req).await
589    }
590
591    pub async fn delete_thread(
592        &mut self,
593        thread_id: String,
594    ) -> Result<common::DeletionStatus, APIError> {
595        self.delete(&format!("threads/{thread_id}")).await
596    }
597
598    pub async fn create_message(
599        &mut self,
600        thread_id: String,
601        req: CreateMessageRequest,
602    ) -> Result<MessageObject, APIError> {
603        self.post(&format!("threads/{thread_id}/messages"), &req)
604            .await
605    }
606
607    pub async fn retrieve_message(
608        &mut self,
609        thread_id: String,
610        message_id: String,
611    ) -> Result<MessageObject, APIError> {
612        self.get(&format!("threads/{thread_id}/messages/{message_id}"))
613            .await
614    }
615
616    pub async fn modify_message(
617        &mut self,
618        thread_id: String,
619        message_id: String,
620        req: ModifyMessageRequest,
621    ) -> Result<MessageObject, APIError> {
622        self.post(&format!("threads/{thread_id}/messages/{message_id}"), &req)
623            .await
624    }
625
626    pub async fn list_messages(&mut self, thread_id: String) -> Result<ListMessage, APIError> {
627        self.get(&format!("threads/{thread_id}/messages")).await
628    }
629
630    pub async fn retrieve_message_file(
631        &mut self,
632        thread_id: String,
633        message_id: String,
634        file_id: String,
635    ) -> Result<MessageFileObject, APIError> {
636        self.get(&format!(
637            "threads/{thread_id}/messages/{message_id}/files/{file_id}"
638        ))
639        .await
640    }
641
642    pub async fn list_message_file(
643        &mut self,
644        thread_id: String,
645        message_id: String,
646        limit: Option<i64>,
647        order: Option<String>,
648        after: Option<String>,
649        before: Option<String>,
650    ) -> Result<ListMessageFile, APIError> {
651        let url = Self::query_params(
652            limit,
653            order,
654            after,
655            before,
656            format!("threads/{thread_id}/messages/{message_id}/files"),
657        );
658        self.get(&url).await
659    }
660
661    pub async fn create_run(
662        &mut self,
663        thread_id: String,
664        req: CreateRunRequest,
665    ) -> Result<RunObject, APIError> {
666        self.post(&format!("threads/{thread_id}/runs"), &req).await
667    }
668
669    pub async fn retrieve_run(
670        &mut self,
671        thread_id: String,
672        run_id: String,
673    ) -> Result<RunObject, APIError> {
674        self.get(&format!("threads/{thread_id}/runs/{run_id}"))
675            .await
676    }
677
678    pub async fn modify_run(
679        &mut self,
680        thread_id: String,
681        run_id: String,
682        req: ModifyRunRequest,
683    ) -> Result<RunObject, APIError> {
684        self.post(&format!("threads/{thread_id}/runs/{run_id}"), &req)
685            .await
686    }
687
688    pub async fn list_run(
689        &mut self,
690        thread_id: String,
691        limit: Option<i64>,
692        order: Option<String>,
693        after: Option<String>,
694        before: Option<String>,
695    ) -> Result<ListRun, APIError> {
696        let url = Self::query_params(
697            limit,
698            order,
699            after,
700            before,
701            format!("threads/{thread_id}/runs"),
702        );
703        self.get(&url).await
704    }
705
706    pub async fn cancel_run(
707        &mut self,
708        thread_id: String,
709        run_id: String,
710    ) -> Result<RunObject, APIError> {
711        self.post(
712            &format!("threads/{thread_id}/runs/{run_id}/cancel"),
713            &ModifyRunRequest::default(),
714        )
715        .await
716    }
717
718    pub async fn create_thread_and_run(
719        &mut self,
720        req: CreateThreadAndRunRequest,
721    ) -> Result<RunObject, APIError> {
722        self.post("threads/runs", &req).await
723    }
724
725    pub async fn retrieve_run_step(
726        &mut self,
727        thread_id: String,
728        run_id: String,
729        step_id: String,
730    ) -> Result<RunStepObject, APIError> {
731        self.get(&format!(
732            "threads/{thread_id}/runs/{run_id}/steps/{step_id}"
733        ))
734        .await
735    }
736
737    pub async fn list_run_step(
738        &mut self,
739        thread_id: String,
740        run_id: String,
741        limit: Option<i64>,
742        order: Option<String>,
743        after: Option<String>,
744        before: Option<String>,
745    ) -> Result<ListRunStep, APIError> {
746        let url = Self::query_params(
747            limit,
748            order,
749            after,
750            before,
751            format!("threads/{thread_id}/runs/{run_id}/steps"),
752        );
753        self.get(&url).await
754    }
755
756    pub async fn create_batch(
757        &mut self,
758        req: CreateBatchRequest,
759    ) -> Result<BatchResponse, APIError> {
760        self.post("batches", &req).await
761    }
762
763    pub async fn retrieve_batch(&mut self, batch_id: String) -> Result<BatchResponse, APIError> {
764        self.get(&format!("batches/{batch_id}")).await
765    }
766
767    pub async fn cancel_batch(&mut self, batch_id: String) -> Result<BatchResponse, APIError> {
768        self.post(
769            &format!("batches/{batch_id}/cancel"),
770            &common::EmptyRequestBody {},
771        )
772        .await
773    }
774
775    pub async fn list_batch(
776        &mut self,
777        after: Option<String>,
778        limit: Option<i64>,
779    ) -> Result<ListBatchResponse, APIError> {
780        let url = Self::query_params(limit, None, after, None, "batches".to_string());
781        self.get(&url).await
782    }
783
784    pub async fn list_models(&mut self) -> Result<ModelsResponse, APIError> {
785        self.get("models").await
786    }
787
788    pub async fn retrieve_model(&mut self, model_id: String) -> Result<ModelResponse, APIError> {
789        self.get(&format!("models/{model_id}")).await
790    }
791
792    pub async fn delete_model(
793        &mut self,
794        model_id: String,
795    ) -> Result<common::DeletionStatus, APIError> {
796        self.delete(&format!("models/{model_id}")).await
797    }
798
799    fn build_url_with_preserved_query(&self, path: &str) -> Result<String, url::ParseError> {
800        let (base, query_opt) = match self.api_endpoint.split_once('?') {
801            Some((b, q)) => (b.trim_end_matches('/'), Some(q)),
802            None => (self.api_endpoint.trim_end_matches('/'), None),
803        };
804
805        let full_path = format!("{}/{}", base, path.trim_start_matches('/'));
806        let mut url = Url::parse(&full_path)?;
807
808        if let Some(query) = query_opt {
809            for (k, v) in url::form_urlencoded::parse(query.as_bytes()) {
810                url.query_pairs_mut().append_pair(&k, &v);
811            }
812        }
813        Ok(url.to_string())
814    }
815
816    fn query_params(
817        limit: Option<i64>,
818        order: Option<String>,
819        after: Option<String>,
820        before: Option<String>,
821        mut url: String,
822    ) -> String {
823        let mut params = vec![];
824        if let Some(limit) = limit {
825            params.push(format!("limit={limit}"));
826        }
827        if let Some(order) = order {
828            params.push(format!("order={order}"));
829        }
830        if let Some(after) = after {
831            params.push(format!("after={after}"));
832        }
833        if let Some(before) = before {
834            params.push(format!("before={before}"));
835        }
836        if !params.is_empty() {
837            url = format!("{}?{}", url, params.join("&"));
838        }
839        url
840    }
841
842    fn is_beta(path: &str) -> bool {
843        path.starts_with("assistants") || path.starts_with("threads")
844    }
845
846    fn create_form<T>(req: &T, file_field: &str) -> Result<Form, APIError>
847    where
848        T: Serialize,
849    {
850        let json = match serde_json::to_value(req) {
851            Ok(json) => json,
852            Err(e) => {
853                return Err(APIError::CustomError {
854                    message: e.to_string(),
855                })
856            }
857        };
858        let file_path = if let Value::Object(map) = &json {
859            map.get(file_field)
860                .and_then(|v| v.as_str())
861                .ok_or(APIError::CustomError {
862                    message: format!("Field '{file_field}' not found or not a string"),
863                })?
864        } else {
865            return Err(APIError::CustomError {
866                message: "Request is not a JSON object".to_string(),
867            });
868        };
869
870        let mut file = match File::open(file_path) {
871            Ok(file) => file,
872            Err(e) => {
873                return Err(APIError::CustomError {
874                    message: e.to_string(),
875                })
876            }
877        };
878        let mut buffer = Vec::new();
879        match file.read_to_end(&mut buffer) {
880            Ok(_) => {}
881            Err(e) => {
882                return Err(APIError::CustomError {
883                    message: e.to_string(),
884                })
885            }
886        }
887
888        let mut form =
889            Form::new().part("file", Part::bytes(buffer).file_name(file_path.to_string()));
890
891        if let Value::Object(map) = json {
892            for (key, value) in map.into_iter() {
893                if key != file_field {
894                    match value {
895                        Value::String(s) => {
896                            form = form.text(key, s);
897                        }
898                        Value::Number(n) => {
899                            form = form.text(key, n.to_string());
900                        }
901                        _ => {}
902                    }
903                }
904            }
905        }
906
907        Ok(form)
908    }
909
910    fn create_form_from_bytes<T>(req: &T, bytes: Vec<u8>) -> Result<Form, APIError>
911    where
912        T: Serialize,
913    {
914        let json = match serde_json::to_value(req) {
915            Ok(json) => json,
916            Err(e) => {
917                return Err(APIError::CustomError {
918                    message: e.to_string(),
919                })
920            }
921        };
922
923        let mut form = Form::new().part("file", Part::bytes(bytes.clone()).file_name("file.mp3"));
924
925        if let Value::Object(map) = json {
926            for (key, value) in map.into_iter() {
927                match value {
928                    Value::String(s) => {
929                        form = form.text(key, s);
930                    }
931                    Value::Number(n) => {
932                        form = form.text(key, n.to_string());
933                    }
934                    _ => {}
935                }
936            }
937        }
938
939        Ok(form)
940    }
941}
openai_api_rs/v1/api.rs

openai_api_rs/v1/
api.rs
