Struct OpenRouterExt 

pub struct OpenRouterExt;

Trait Implementations

impl<H> Capabilities<H> for OpenRouterExt

type Completion = Capable<GenericCompletionModel<OpenRouterExt, H>>

Completion model capability marker.

type Embeddings = Capable<GenericEmbeddingModel<OpenRouterExt, H>>

Embedding model capability marker.

type Transcription = Capable<GenericTranscriptionModel<OpenRouterExt, H>>

Audio transcription model capability marker.

type ModelListing = Capable<OpenRouterModelLister<H>>

Model listing capability marker.

type ImageGeneration = Nothing

Available on crate feature image only.

Image generation model capability marker.

type AudioGeneration = Capable<GenericAudioGenerationModel<OpenRouterExt, H>>

Available on crate feature audio only.

Audio generation model capability marker.

type Rerank = Nothing

Rerank model capability marker.

impl Clone for OpenRouterExt

fn clone(&self) -> OpenRouterExt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for OpenRouterExt

impl Debug for OpenRouterExt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DebugExt for OpenRouterExt

fn fields(&self) -> impl Iterator<Item = (&'static str, &dyn Debug)>

Additional provider-specific fields to include in Client debug output.

impl Default for OpenRouterExt

fn default() -> OpenRouterExt

Returns the “default value” for a type.

impl OpenAICompatibleProvider for OpenRouterExt

fn streaming_detail_reasoning( &self, detail: &Value, ) -> Option<(StreamPartId, Option<WireId>, ReasoningContent)>

Encrypted reasoning ({"type":"reasoning.encrypted"}) is the turn’s own output, not tool-call metadata: it arrives with reasoning: null and an rs_* id of its own, which never matches a call_* tool-call id, and it arrives before any tool call opens. Emitting it as a reasoning block matches the non-streaming path (which maps the same detail to message::ReasoningContent::Encrypted) and is what lets the blob reach the aggregated choice and be replayed on the next turn.

fn streaming_reasoning_signature(&self, detail: &Value) -> Option<String>

Anthropic routes stream the plaintext in delta.reasoning, then send its replay-required signature as a final signature-only reasoning.text detail immediately before the tool call. Feed that authoritative close into the shared lifecycle so the normalized reasoning block is signed just like the blocking response.

const PROVIDER_NAME: &'static str = self::PROVIDER_NAME

Provider name recorded on gen_ai.provider.name telemetry spans.

const STREAM_INCLUDE_USAGE: bool = false

Whether streaming requests include "stream_options": {"include_usage": true}. Providers that reject unknown parameters and already report usage on the final chunk set this to false.

type StreamingUsage = Usage

The usage payload parsed from streaming chunks and carried on the final streaming response. OpenAI’s Usage for most providers; providers with richer usage accounting (e.g. Mistral’s cached-token fallbacks, DeepSeek’s cache hit/miss counters) substitute their own.

type Response = CompletionResponse

The chat-completions payload this provider returns.

fn map_streaming_finish_reason( &self, finish_reason: Option<&str>, native_finish_reason: Option<&str>, ) -> Option<FinishReason>

Map a streamed terminal reason for this compatible provider.

fn build_completion_request( &self, model: String, request: CompletionRequest, options: CompletionModelOptions, ) -> Result<CompletionRequest, CompletionError>

Build the typed chat-completions request. Providers that share the OpenAI transport but need provider-specific message conversion can override this while still using GenericCompletionModel for sending, streaming, error handling, and telemetry.

fn finalize_request_body_with_options( &self, body: &mut Value, options: CompletionModelOptions, ) -> Result<(), CompletionError>

Adjust the fully serialized request body with model-level options. Providers that do not need model-instance options should override finalize_request_body instead.

const REQUEST_ID_HEADER: Option<&'static str> = None

Response header carrying the provider’s transport request id, when the provider reports one (OpenAI sends x-request-id). None — the default — means the provider does not report one; the normalized response’s provider_request_id is then None, never an error.

const EMITS_COMPLETE_SINGLE_CHUNK_TOOL_CALLS: bool = false

Whether the backend can emit a whole tool call (id, name, and complete arguments) in a single streaming chunk, as llama.cpp-based servers do. When true, the shared streaming layer emits such calls as soon as they arrive instead of holding them until the stream ends.

const SUPPORTS_TOOLS: bool = true

Whether the provider supports tool calling. When false, tools and tool_choice are dropped with a warning during request conversion — before tool-choice validation, so unsupported tool configurations never error client-side on a provider that ignores tools anyway.

const SUPPORTS_RESPONSE_FORMAT: bool = true

Whether output_schema maps to OpenAI’s response_format. Providers whose APIs reject json_schema response formats set this to false; the schema is then dropped with a warning instead of being sent.

fn requires_modern_output_cap(&self, model: &str) -> bool

Whether model’s endpoint rejects the legacy max_tokens field and requires max_completion_tokens instead.

fn completion_path(&self, model: &str) -> String

The request path for chat completions, resolved against the client base URL by Provider::build_uri. Providers that route the model through the URL (e.g. Azure deployment paths) or keep other capabilities on differently-versioned paths override this. model is the identifier the completion model handle was created with; per-request model overrides only affect the body.

fn prepare_request( &self, request: &mut CompletionRequest, ) -> Result<(), CompletionError>

Adjust the typed request before serialization (e.g. rewrite the model identifier or fold provider-native tool definitions out of additional_params).

fn finalize_request_body(&self, body: &mut Value) -> Result<(), CompletionError>

Adjust the fully serialized request body — after any streaming parameters are merged — immediately before it is sent. This is where wire-level dialect differences live (e.g. Mistral’s "any" tool choice, DeepSeek’s string-flattened message content).

fn decorate_streaming_tool_call( &self, detail: &Value, ) -> Option<ToolCallDecoration>

Decorate a streamed tool call from a provider-specific streaming detail payload, matched by its established provider id. Most OpenAI-compatible providers do not emit such details.

impl Provider for OpenRouterExt

const VERIFY_PATH: &'static str = "/key"

Provider endpoint used by VerifyClient to validate credentials.

type Builder = OpenRouterExtBuilder

The builder type that constructs this provider extension. This associates extensions with their builders for type inference.

fn build_uri(&self, base_url: &str, path: &str, _transport: Transport) -> String

Build a complete request URI for the given base URL, provider path, and transport.

fn with_custom(&self, req: Builder) -> Result<Builder>

Apply provider-specific request customization before sending.