A Rust library guide for sending requests to OpenAI-compatible language-model servers such as LM Studio, llama.cpp, and vLLM. It covers streamed replies, tool calls, structured JSON output, and image input, but does not provide an agent loop or conversation storage.

Use it to build Rust applications that call local or hosted language models, process streaming answers, require or forbid tool calls, and parse model output into typed data.

It explains the differences in this library's request and response format so Rust code does not lose streamed data or tool calls. You must provide any conversation history or agent logic yourself.

How ferrus-dev/ferrus configures Claude Code and Codex

Reuse

Borrowing it

Nothing to install: this file belongs to ferrus-dev/ferrus. Take a copy, put it at the same path in your own repository, and replace the rules that are about this project with yours.

Copy the file

curl -O https://raw.githubusercontent.com/ferrus-dev/ferrus/main/.agents/skills/svir/SKILL.md

Clone the repo

git clone --depth 1 https://github.com/ferrus-dev/ferrus

Made for: Claude Code, Codex.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

README.md

[![agentmods](https://agentmods.dev/badge/skills/ferrus-dev/ferrus/svir/github.svg)](https://agentmods.dev/skills/ferrus-dev/ferrus/svir)

Your own site

<a href="https://agentmods.dev/skills/ferrus-dev/ferrus/svir"><img src="https://agentmods.dev/badge/skills/ferrus-dev/ferrus/svir/github.svg" alt="Measured on agentmods" height="20"></a>

Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.

Your own site · 80×15

<a href="https://agentmods.dev/skills/ferrus-dev/ferrus/svir"><img src="https://agentmods.dev/badge/skills/ferrus-dev/ferrus/svir.svg" alt="Reviewed on agentmods" width="80" height="20"></a>

Per session 169 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.

When invoked 4,288 The whole file, excluding the scripts and references it only reads on demand.

Security scan A 0 findings. A grade says what 26 rules found in the file — not that it is safe.

Origin original No closer match found in the catalogue.

Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

Model	Per session	Once invoked
Fable 5.1	$0.00169	$0.04288
Opus 5.5	$0.00068	$0.01715
Sonnet 5.5	$0.00034	$0.00858
Haiku 4.5	$0.00017	$0.00429

Measured 12d ago against content hash 852e1f554449, method: parsed. Prices are Anthropic first-party input rates as of 2026-10-07, from the pricing page.

Security

Grade A, and why

svir scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 12d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.agents/skills/svir/SKILL.md · 308 lines

How it starts

The opening of the file, as written. The whole thing — 308 lines — stays where its author put it; the contents beside it link to each section on GitHub.

svir -- talking to LLMs from Rust

svir is the wire protocol between an application and a model server: types, an encoder, a decoder, a transport, and the compatibility handling real servers need. Layers (middleware) and tool sets sit on top, opt-in. It is not an agent framework: there is no agent loop, no session history, no storage, and no MCP. Those are a few lines of the caller's code, and this skill shows them.

This skill describes svir 0.1.x, which speaks one wire API: OpenAI-compatible Chat Completions, always streamed. Its shape is unlike the LLM SDKs most code was written against. The conversation is the request, the system prompt is a field, the answer is one stream whose last item is the whole answer, and an error is a kind to match on. Code written from habit -- a system role message, choices[0].delta.content, a client that remembers the chat -- does not compile here, or compiles and loses tool calls. The Non-negotiables are the places where that happens. Read them before writing code.

Step 1 -- establish the version and the features

cargo add svir
cargo add tokio --features macros,rt-multi-thread

In an existing project, read Cargo.toml first:

What you find	What it means
`svir = "0.1"` and no `features` key	`client` and `tls` are on: everything here except `Tools::add`, `Schema::of`, and the `Trace` layer
`svir = "=0.1.0"`, or a lock file on 0.1.0	No `Error::status()`, no `tls-aws-lc`, a 4 MiB default wire limit, and inline `<think>` tags left in the answer when a delta is only part of a tag. Later 0.1 releases are drop-in
`svir = "=0.1.1"`, or a lock file on 0.1.1	No `FinishReason::ContentFilter`: a filtered answer is `Unsupported`. Azure OpenAI streams fail in strict mode with "an empty choices array before the finish reason". Later 0.1 releases are drop-in
`svir = "=0.1.2"`, or a lock file on 0.1.2	No `ErrorKind::ContentFilter`: a prompt the content filter blocked is `Unsupported`, and, since usage is asked for by default, is sent a second time without `reasoning_effort` and `stream_options`. An annotation from Azure's asynchronous content filter fails the stream with `Unsupported`. Later 0.1 releases are drop-in
`svir = "=0.1.3"`, or a lock file on 0.1.3	No `ToolResult::error` and no `is_error`: a failed call is a plain `ToolResult` whose content starts with `error:` , which is also what `Tools` writes. No `ClientBuilder::header`, no `TextFile::escaped_len`. Later 0.1 releases are drop-in, except that a `Tools` failure no longer has `error:` in its `content`: test `result.is_error`
`svir = "=0.1.4"`, or a lock file on 0.1.4	No `tool_choice`, no `response_format`, no `Schema`, no `Completion::parse`, no `FinishReason::Refusal`: a refusal fails strict decoding with `Unsupported`, and lenient decoding drops it and completes with `Stop` and no text. 0.1.5 is drop-in, except that a refusal now completes with its text and the finish `Refusal`
`svir = "=0.1.5"`, or a lock file on 0.1.5	Reasoning that mlx-vlm sends under both `reasoning_content` and `reasoning` arrives twice: two `Reasoning` events for every piece, and two entries in `Completion::reasoning`. A call of a named tool that vLLM finishes with `stop` fails with `Protocol`. An error in FastAPI's form, `{"detail": ...}` (mlx-vlm), has no `server_message()`, and mlx-vlm's context overflows are `Unsupported`. 0.1.6 is drop-in
`svir = "=0.1.6"`, or a lock file on 0.1.6	No `Effort::Minimal` or `Effort::Max`, no `Completion::cut_calls`, no `ClientBuilder::lean_retry`. With a `Length` finish, calls the output limit may have cut short are in `calls`, where they look executable: check the finish before running them. A call with no ID or no name in such an answer fails with `Protocol`. 0.1.7 is drop-in, except that `calls` is empty with a `Length` finish: the calls are in `cut_calls`
`features = ["schemars"]`	`Tools::add`, which derives a tool's input schema from its argument type, and `Schema::of`, which derives an answer's schema from a type
`features = ["tracing"]`	The `Trace` layer
`default-features = false`	Types and the codec only: no `Client`, no `EventStream`, no layers, no attachments read from disk. Read `references/codec.md`
`default-features = false, features = ["client"]`	The client without HTTPS: an `https://` URL is a `Config` error at `build()`
`default-features = false, features = ["client", "tls-aws-lc"]`	HTTPS with the aws-lc-rs crypto provider in place of ring. Everything here applies

Read the full file on GitHub · 308 lines

Files

What ships with it

7 files beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

12d ago First seen · 308 lines · 169 tokens per session scan A 852e1f554449

Subscribe to this mod's changes

svir is a skill published in the GitHub repository ferrus-dev/ferrus (2 stars, last pushed 7d ago), licensed Apache-2.0. It adds 169 tokens to every session and 4,288 once invoked, about $0.0007 per session on Opus 5.5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-10-25.

Data and AI Languages Prompting Rust agent-orchestration ai-agents automation deterministic-systems developer-tools mcp

svir next to 6 skills from other repositories
Mod	Type	Stars	Last push	Licence	Scan	Tokens	Works with
svirferrus-dev/ferrus	Skill	2	7d ago	Apache-2.0	A	169	Claude Code, Codex
v4-best-practicesHmbown/CodeWhale	Skill	41k	5d ago	MIT	A	51	Claude Code, Codex
developing-genkit-jsgoogle/skills	Skill	22k	yesterday	Apache-2.0	A	60	Claude Code, Codex
rust-checkHmbown/CodeWhale	Skill	41k	5d ago	MIT	A	15	Claude Code, Codex
ax-signatureax-llm/ax	Skill	3.0k	3d ago	Apache-2.0	A	57	Claude Code, Codex
ax-rust-signatureax-llm/ax	Skill	3.0k	3d ago	Apache-2.0	A	36	Claude Code, Codex
ax-cpp-gepaax-llm/ax	Skill	3.0k	3d ago	Apache-2.0	A	39	Claude Code, Codex

ferrus: Skill for Claude Code