⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
slop
This skill should be used when the user asks to "remove slop", "deslop", "clean up slop", "clean up the diff", "strip AI slop from this change", or runs /slop after a change, to remove noise from changed oas3-gen Rust code while preserving behavior. Accepts an optional path, commit, or revision range to clean instead of the uncommitted changes.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
(OAS3-GEN) OpenAPI 3.1+ Rust Generator
// ██████╗ █████╗ ███████╗██████╗ ██████╗ ███████╗███╗ ██╗
// ██╔═══██╗██╔══██╗██╔════╝╚════██╗ ██╔════╝ ██╔════╝████╗ ██║
// ██║ ██║███████║███████╗ █████╔╝█████╗██║ ███╗█████╗ ██╔██╗ ██║
// ██║ ██║██╔══██║╚════██║ ╚═══██╗╚════╝██║ ██║██╔══╝ ██║╚██╗██║
// ╚██████╔╝██║ ██║███████║██████╔╝ ╚██████╔╝███████╗██║ ╚████║
// ╚═════╝ ╚═╝ ╚═╝╚══════╝╚═════╝ ╚═════╝ ╚══════╝╚═╝ ╚═══╝
Generate Rust types, a reqwest HTTP client, or an axum server trait and router
from an OpenAPI 3.1 document. The generator accepts JSON and YAML input.
Quick Start
You'll need Rust 1.89 or later. Install the generator:
cargo install oas3-gen
Alternative build with Nix
- Make sure you have
nixinstalled or install it with:sh <(curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install) --daemon - Now simply run it with:
nix run github:eklipse2k8/oas3-genwill run the binary, fetching the git repo automatically.- Or locally in the repo with
nix run - To globally install use
nix profile install
Generate a client crate from your API document:
oas3-gen generate client-mod -i api.json -o my-api --workspace
cargo check --manifest-path my-api/Cargo.toml
Replace api.json with the path to your document. To try the repository's
example, use fixtures/petstore.json. The output
contains a Cargo.toml with the required dependencies and a src/ directory
with the client and its types.
To generate a server crate, use server-mod:
oas3-gen generate server-mod -i api.json -o my-server --workspace
You'll implement the generated trait to handle requests. If you only need data types, generate a single file:
oas3-gen generate types -i api.json -o types.rs
Generated Client
The petstore client includes this method for its health endpoint. This excerpt omits imports and the other methods:
impl PetstoreClient {
pub async fn get_health(
&self,
request: GetHealthRequest,
) -> anyhow::Result<ApiResponse<(), ()>> {
request.validate().context("parameter validation")?;
let mut url = self.base_url.clone();
url.path_segments_mut()
.map_err(|()| anyhow::anyhow!("URL cannot be a base"))?
.push("health");
let response = self.client.get(url).send().await?;
GetHealthRequest::parse_response(response).await
}
}
The method sends the request through reqwest::Client and
passes the response to the generated decoder.
Generated Server
Server output declares a trait method for the same operation. This excerpt omits the other operations:
pub trait ApiServer: Send + Sync {
fn get_health(
&self,
request: GetHealthRequest,
) -> impl std::future::Future<Output = anyhow::Result<ApiResponse<(), ()>>> + Send;
}
Implement ApiServer, then pass your service to the generated router()
function. It returns an axum::Router that extracts requests,
calls your methods, and writes HTTP responses.
Features
| Feature | Generated behavior |
|---|---|
| Types | Structs, enums, type aliases, and unions with Serde serialization where needed |
| HTTP clients | Async methods for API operations, with typed requests and responses |
| Axum servers | A service trait, request extractors, handlers, and routes |
| Body formats | JSON, text, and binary data, plus form and multipart requests |
| Authentication | API keys in headers, query parameters, and cookies, plus bearer tokens |
| Event streams | Server-Sent Events on both clients and servers |
| Validation | Checks for supported schema constraints, including lengths, ranges, patterns, and multipleOf |
| Builders | Optional bon builders for schema values and requests |
| Generation options | Operation filtering, name overrides, visibility, enum handling, and type adapters |
Learn More
Read the book for client and server
walkthroughs, generation options, schema mappings, and known limitations.
Run oas3-gen generate --help for command-line usage.
Contributing
See CONTRIBUTING.md for contribution requirements and the pull request process. Report bugs or suggest changes in GitHub issues.
License
Licensed under the MIT license.
Copyright (c) 2026 Individual contributors
See [OpenAPI v3.1.2]: https://spec.openapis.org/oas/v3.1.2
// HOW IT'S BUILT
KEY FILES