feat: complete spec sync (64bit#473)

* add project rate limits api

* add usage api

* add usage example

* fix test

* fix test

* admin api keys api

* certificates api

* fix test

* nest admin apis in client.admin()

* nested types for admin apis

* fix example compilation

* types::assistants

* fix imports in the examples

* fix

* fix test

* only unsigned types

* add remanining byot tests

* add realtime apis

* u64 for timestamps

* fix

* upated readme

* updated readme license

* add community project back

* update docs for dynamic dispatch

* update readme

* update readme

* fix test

* updated spec

* cargo fmt

(cherry picked from commit 4754c24)

# Conflicts:
#	async-openai/README.md
#	async-openai/src/audit_logs.rs
#	async-openai/src/client.rs
#	async-openai/src/invites.rs
#	async-openai/src/project_api_keys.rs
#	async-openai/src/projects.rs
#	async-openai/src/steps.rs
#	async-openai/src/types/assistants/assistant_impls.rs
#	async-openai/src/types/impls.rs
#	async-openai/src/users.rs
#	async-openai/tests/completion.rs
#	async-openai/tests/ser_de.rs
#	examples/assistants-code-interpreter/src/main.rs
#	examples/assistants-file-search/src/main.rs
#	examples/assistants-func-call-stream/src/main.rs
#	examples/assistants/src/main.rs

Author: 64bit

async-openai/README.md

@@ -17,40 +17,33 @@ project is and will be done manually when `async-openai` releases a new version.
 with `async-openai` releases, which means when `async-openai` releases `x.y.z`, `async-openai-wasm` also releases
 a `x.y.z` version.
 
-`async-openai-wasm` is an unofficial Rust library for OpenAI.
-
-- It's based on [OpenAI OpenAPI spec](https://github.com/openai/openai-openapi)
-- Current features:
-    - [x] Administration (partially implemented)
-  - [x] Assistants (beta)
-    - [x] Audio
-    - [x] Batch
-    - [x] Chat
-  - [x] ChatKit (beta)
-    - [x] Completions (legacy)
-    - [x] Conversations
-  - [x] Containers
-  - [x] Embeddings
-  - [x] Evals
-  - [x] Files
-  - [x] Fine-Tuning
-  - [x] Images
-  - [x] Models
-  - [x] Moderations
-  - [x] Realtime (partially implemented)
-  - [x] Responses
-  - [x] Uploads
-  - [x] Vector Stores
-  - [x] Videos
-  - [x] Webhooks
-  - [x] **WASM support**
-  - [x] Reasoning Model Support: support models like DeepSeek R1 via broader support for OpenAI-compatible endpoints, see `examples/reasoning`
+`async-openai-wasm` is an unofficial Rust library for OpenAI, based on [OpenAI OpenAPI spec](https://github.com/openai/openai-openapi). It implements all APIs from the spec:
+
+| Features | APIs |
+|---|---|
+| **Responses API** | Responses, Conversations, Streaming events |
+| **Webhooks** | Webhook Events |
+| **Platform APIs** | Audio, Audio Streaming, Videos, Images, Image Streaming, Embeddings, Evals, Fine-tuning, Graders, Batch, Files, Uploads, Models, Moderations |
+| **Vector stores** | Vector stores, Vector store files, Vector store file batches |
+| **ChatKit** <sub>(Beta)</sub> | ChatKit |
+| **Containers** | Containers, Container Files |
+| **Realtime** | Realtime Calls, Client secrets, Client events, Server events |
+| **Chat Completions** | Chat Completions, Streaming |
+| **Assistants** <sub>(Beta)</sub> | Assistants, Threads, Messages, Runs, Run steps, Streaming |
+| **Administration** | Administration, Admin API Keys, Invites, Users, Projects, Project users, Project service accounts, Project API keys, Project rate limits, Audit logs, Usage, Certificates |
+| **Legacy** | Completions |
+
+Features that makes `async-openai` unique:
 - Bring your own custom types for Request or Response objects.
 - SSE streaming on available APIs
 - Ergonomic builder pattern for all request objects.
 - Microsoft Azure OpenAI Service (only for APIs matching OpenAI spec)
 - Bring your own custom types for Request or Response objects.
 
+More on `async-openai-wasm`:
+- **WASM support**
+- Reasoning Model Support: support models like DeepSeek R1 via broader support for OpenAI-compatible endpoints, see `examples/reasoning`
+
 **Note on Azure OpenAI Service (AOS)**:  `async-openai-wasm` primarily implements OpenAI spec, and doesn't try to
 maintain parity with spec of AOS. Just like `async-openai`.
 
@@ -88,9 +81,9 @@ $Env:OPENAI_API_KEY='sk-...'
   and [WASM examples](https://github.com/ifsheldon/async-openai-wasm/tree/main/examples) in `async-openai-wasm`.
 - Visit [docs.rs/async-openai](https://docs.rs/async-openai) for docs.
 
-## Realtime API
+## Realtime
 
-Only types for Realtime API are implemented, and can be enabled with feature flag `realtime`.
+Realtime types and APIs can be enabled with feature flag `realtime`.
 
 Again, the types do not bundle with a specific WS implementation. Need to convert a client event into a WS message by yourself, which is just simple `your_ws_impl::Message::Text(some_client_event.into_text())`.
 
@@ -142,20 +135,66 @@ async fn main() -> Result<(), Box<dyn Error>> {
   <sub>Scaled up for README, actual size 256x256</sub>
 </div>
 
-## Dynamic Dispatch for Different Providers
+## Bring Your Own Types
 
-For any struct that implements `Config` trait, you can wrap it in a smart pointer and cast the pointer to `dyn Config`
-trait object, then your client can accept any wrapped configuration type.
+Enable methods whose input and outputs are generics with `byot` feature. It creates a new method with same name and `_byot` suffix. 
 
-For example,
+`byot` requires trait bounds: 
+- a request type (`fn` input parameter) needs to implement `serde::Serialize` or `std::fmt::Display` trait
+- a response type (`fn` ouput parameter) needs to implement `serde::de::DeserializeOwned` trait.
 
+For example, to use `serde_json::Value` as request and response type:
 ```rust
-use async_openai::{Client, config::Config, config::OpenAIConfig};
+let response: Value = client
+        .chat()
+        .create_byot(json!({
+            "messages": [
+                {
+                    "role": "developer",
+                    "content": "You are a helpful assistant"
+                },
+                {
+                    "role": "user",
+                    "content": "What do you think about life?"
+                }
+            ],
+            "model": "gpt-4o",
+            "store": false
+        }))
+        .await?;
+```
+
+This can be useful in many scenarios:
+- To use this library with other OpenAI compatible APIs whose types don't exactly match OpenAI. 
+- Extend existing types in this crate with new fields with `serde` (for example with `#[serde(flatten)]`).
+- To avoid verbose types.
+- To escape deserialization errors.
+
+Visit [examples/bring-your-own-type](https://github.com/64bit/async-openai/tree/main/examples/bring-your-own-type)
+directory to learn more.
+
+## Dynamic Dispatch for OpenAI-compatible Providers
+
+This allows you to use same code (say a `fn`) to call APIs on different OpenAI-compatible providers.
+
+For any struct that implements `Config` trait, wrap it in a smart pointer and cast the pointer to `dyn Config`
+trait object, then create a client with `Box` or `Arc` wrapped configuration.
 
-let openai_config = OpenAIConfig::default();
-// You can use `std::sync::Arc` to wrap the config as well
-let config = Box::new(openai_config) as Box<dyn Config>;
-let client: Client<Box<dyn Config> > = Client::with_config(config);
+For example:
+
+```rust
+use async_openai::{Client, config::{Config, OpenAIConfig}};
+
+// Use `Box` or `std::sync::Arc` to wrap the config
+let config = Box::new(OpenAIConfig::default()) as Box<dyn Config>;
+// create client
+let client: Client<Box<dyn Config>> = Client::with_config(config);
+
+// A function can now accept a `&Client<Box<dyn Config>>` parameter
+// which can invoke any openai compatible api
+fn chat_completion(client: &Client<Box<dyn Config>>) { 
+    todo!() 
+}
 ```
 
 ## Contributing
@@ -165,11 +204,14 @@ project [async-openai](https://github.com/64bit/async-openai).
 
 This project adheres to [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
 
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in async-openai by you, shall be licensed as MIT, without any additional terms or conditions.
+
 ## Why `async-openai-wasm`
 
 Because I wanted to develop and release a crate that depends on the wasm feature in `experiments` branch
 of [async-openai](https://github.com/64bit/async-openai), but the pace of stabilizing the wasm feature is different
 from what I expected.
+- [openai-func-enums](https://github.com/frankfralick/openai-func-enums) macros for working with function/tool calls.
 
 ## License
 

async-openai/src/admin.rs

@@ -0,0 +1,46 @@
+use crate::{
+    Client, admin_api_keys::AdminAPIKeys, audit_logs::AuditLogs, certificates::Certificates,
+    config::Config, invites::Invites, projects::Projects, users::Users,
+};
+
+/// Admin group for all administration APIs.
+/// This groups together admin API keys, invites, users, projects, audit logs, and certificates.
+pub struct Admin<'c, C: Config> {
+    client: &'c Client<C>,
+}
+
+impl<'c, C: Config> Admin<'c, C> {
+    pub(crate) fn new(client: &'c Client<C>) -> Self {
+        Self { client }
+    }
+
+    /// To call [AdminAPIKeys] group related APIs using this client.
+    pub fn api_keys(&self) -> AdminAPIKeys<'_, C> {
+        AdminAPIKeys::new(self.client)
+    }
+
+    /// To call [Invites] group related APIs using this client.
+    pub fn invites(&self) -> Invites<'_, C> {
+        Invites::new(self.client)
+    }
+
+    /// To call [Users] group related APIs using this client.
+    pub fn users(&self) -> Users<'_, C> {
+        Users::new(self.client)
+    }
+
+    /// To call [Projects] group related APIs using this client.
+    pub fn projects(&self) -> Projects<'_, C> {
+        Projects::new(self.client)
+    }
+
+    /// To call [AuditLogs] group related APIs using this client.
+    pub fn audit_logs(&self) -> AuditLogs<'_, C> {
+        AuditLogs::new(self.client)
+    }
+
+    /// To call [Certificates] group related APIs using this client.
+    pub fn certificates(&self) -> Certificates<'_, C> {
+        Certificates::new(self.client)
+    }
+}

async-openai/src/admin_api_keys.rs

@@ -0,0 +1,60 @@
+use serde::Serialize;
+
+use crate::{
+    Client,
+    config::Config,
+    error::OpenAIError,
+    types::admin::api_keys::{
+        AdminApiKey, AdminApiKeyDeleteResponse, ApiKeyList, CreateAdminApiKeyRequest,
+    },
+};
+
+/// Admin API keys enable Organization Owners to programmatically manage various aspects of their
+/// organization, including users, projects, and API keys. These keys provide administrative capabilities,
+/// allowing you to automate organization management tasks.
+pub struct AdminAPIKeys<'c, C: Config> {
+    client: &'c Client<C>,
+}
+
+impl<'c, C: Config> AdminAPIKeys<'c, C> {
+    pub fn new(client: &'c Client<C>) -> Self {
+        Self { client }
+    }
+
+    /// List all organization and project API keys.
+    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+    pub async fn list<Q>(&self, query: &Q) -> Result<ApiKeyList, OpenAIError>
+    where
+        Q: Serialize + ?Sized,
+    {
+        self.client
+            .get_with_query("/organization/admin_api_keys", &query)
+            .await
+    }
+
+    /// Create an organization admin API key.
+    pub async fn create(
+        &self,
+        request: CreateAdminApiKeyRequest,
+    ) -> Result<AdminApiKey, OpenAIError> {
+        self.client
+            .post("/organization/admin_api_keys", request)
+            .await
+    }
+
+    /// Retrieve a single organization API key.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn retrieve(&self, key_id: &str) -> Result<AdminApiKey, OpenAIError> {
+        self.client
+            .get(format!("/organization/admin_api_keys/{key_id}").as_str())
+            .await
+    }
+
+    /// Delete an organization admin API key.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn delete(&self, key_id: &str) -> Result<AdminApiKeyDeleteResponse, OpenAIError> {
+        self.client
+            .delete(format!("/organization/admin_api_keys/{key_id}").as_str())
+            .await
+    }
+}

async-openai/src/assistants.rs

@@ -4,7 +4,7 @@ use crate::{
     Client,
     config::Config,
     error::OpenAIError,
-    types::{
+    types::assistants::{
         AssistantObject, CreateAssistantRequest, DeleteAssistantResponse, ListAssistantsResponse,
         ModifyAssistantRequest,
     },

async-openai/src/audit_logs.rs

@@ -1,6 +1,8 @@
 use serde::Serialize;
 
-use crate::{Client, config::Config, error::OpenAIError, types::ListAuditLogsResponse};
+use crate::{
+    Client, config::Config, error::OpenAIError, types::admin::audit_logs::ListAuditLogsResponse,
+};
 
 /// Logs of user actions and configuration changes within this organization.
 /// To log events, you must activate logging in the [Organization Settings](https://platform.openai.com/settings/organization/general).