Surface coverage

Solwyn wraps the client you already use, so you keep calling your provider's own methods. When a call reaches the wrapper, exactly one thing happens to it: Solwyn either meters it (budget check plus a cost event), records it without a price, warns once and steps aside, refuses it, or passes it straight through in silence. This page lists every surface and the posture it gets.

One invariant holds across all of them: Solwyn is a wrapper, not a proxy, so the call still goes directly to the provider, and only bounded metadata — integer and float quantities (token counts, image counts, whole-second durations, character counts) and short selector strings (resolution, quality) — leaves your process. Never a prompt, never media bytes, never a transcript, never generated content. See Privacy for the full wire contract.

The five postures

Everything below sorts each concrete surface into one of these.

Priced

Budget-checked before the request — an over-budget call is denied before the provider is reached — then recorded as a cost event tagged with a modality, which the Cloud API prices per-token or per-unit from the model's price card.

Video generation is asynchronous and the job carries no usage, so — because neither provider charges for a failed or blocked generation — video billing settles at initiation: the cost event is recorded at request time and always flagged is_estimated, a deliberate, conservative over-count. Its pre-flight budget check is nonetheless exact, so an over-budget request is denied before the provider is called.

For each modality, only the quantities and selectors leave your process — never the prompt, never a reference image, never the returned bytes.

Recorded but unpriced

Some calls are genuinely billable but expose no observable quantity to price on. Rather than invent a number or fabricate a $0, Solwyn records the event and leaves it unpriced on the dashboard — an honesty lane, visible but explicitly not costed:

• A whisper-1 or compat transcription with a non-JSON response_format (text, srt, vtt) — the provider returns no usage block. The SDK warns once suggesting a JSON response_format.
• A Veo generate_videos call with no config.duration_seconds — Google publishes no default duration, so there is no basis to price on and none is guessed.
• Any unit-priced call whose quantity could not be observed.
• A Bedrock call whose model is an opaque ARN the Cloud API cannot resolve to a price card.
• Zero-cost local providers (ollama, vllm, lmstudio) and the generic openai_compatible catch-all — providers with no price book, where any model is recorded for visibility and never silently costed.

Warn once, then pass through

A recognized spend surface that Solwyn does not yet meter logs exactly one warning per surface per process — naming only the provider and surface, never request data — and then runs the call untracked, with no budget check and no cost event:

• OpenAI's audio.translations.
• Token-billed TTS models such as gpt-4o-mini-tts, which return no usage metadata of any kind — a deliberate product decision to pass them through rather than fabricate a count.

Individual provider adapters may also declare their own not-yet-metered billable surfaces here; on the native Together client, completions, rerank, code_interpreter, and evals warn once and pass through. See Together AI.

Fails loud

A primary spend surface Solwyn cannot track without bypassing the budget or buffering customer content raises instead of running silently untracked:

• On Bedrock, invoke_model, invoke_model_with_response_stream, and start_async_invoke raise ConfigurationError. Their usage lives inside a consume-once body alongside response content (invoke_model), or lands out-of-band in S3 (start_async_invoke), so it cannot be extracted without violating the privacy boundary. Use converse / converse_stream, or call the unwrapped boto3 client directly for deliberately untracked calls.
• videos.create on an OpenAI-compatible or native Together client raises UnsupportedSurfaceError: Solwyn's video interception is wired for OpenAI's Sora only, and no video seam exists on the OpenAI-compatible dialect those clients speak — so the call fails loud rather than passing through as if untracked.
• The same rule holds for any media surface an adapter serves no seam for — embeddings.create on a wrapped Anthropic client, for instance, raises UnsupportedSurfaceError rather than running untracked.

Silent pass-through

Surfaces that are not spend surfaces Solwyn meters are forwarded to your underlying client with no warning and no cost event. This is deliberate — they carry no billable LLM usage:

• files, moderations, batches, fine_tuning, models.list, and the Responses API used as a call surface.
• Any other attribute Solwyn does not intercept — it is proxied straight to the client you passed in.

Deliberately-unbilled models

When a pre-flight budget check names a model the Cloud API has deliberately chosen not to price, the API answers the check with a structured 422. The SDK treats that like any non-2xx and resolves it through the standard fail-open path: the call is allowed and proceeds untracked. Solwyn never blocks a call solely because it cannot yet price it.

What leaves your process

Across every posture above, the privacy boundary is identical: bounded metadata only — the MetadataEvent counts, durations, character counts, and selector strings, plus structural labels and any tags you attach yourself. No prompt, no media bytes, no transcript, no generated content ever leaves your process. Per-provider detail lives on each provider page.