Last updated 2026-05-17

Changelog

User-visible changes to llmrouter, newest first. Internal refactors that don’t affect callers are omitted here — read the commit log if you want the full history.

Versions follow semantic versioning. While we are pre-1.0, expect minor breakages between minor versions; patch releases never change the public API.

The GitHub Releases page has the auto-generated commit-level notes for every tag. This page is the curated, human-written summary.

v0.8.0 — 2026-05-17

The Router, Vertex AI Anthropic, Azure Serverless, Deepgram decode fix.

The headline release for the "magic model × platform" story. A new router/ package decouples the model vendor from the hosting platform; two new provider packages (vertexanthropic, azureserverless) fill in the Vertex Claude story and unlock the Llama / Mistral / Cohere / Phi / DeepSeek catalogue on Azure; Issue #9 (Deepgram decode bug) is fixed; the test suite grew by ~127 new regression tests.

New router package

  • New API: router.Resolve(Request{Model, Platform, Credentials}) (llmrouter.Provider, error) and router.ResolveFromEnv(model string) (llmrouter.Provider, error).
  • 12 platforms: PlatformAuto, PlatformDirect, PlatformBedrock, PlatformVertex, PlatformAzure, PlatformOpenRouter, PlatformTogether, PlatformGroq, PlatformFireworks, PlatformCerebras, PlatformDeepSeek, PlatformPerplexity, PlatformxAI.
  • 9 model families: FamilyOpenAI, FamilyAnthropic, FamilyLlama, FamilyMistral, FamilyCohere, FamilyGemini, FamilyGrok, FamilyDeepSeek, FamilyOther. Family inference via prefix matching after stripping hosting-platform vendor prefixes.
  • Model-id translation: router.ApplyModelTranslation(req, platform) rewrites vendor-neutral ids to Bedrock prefixed form (anthropic.claude-3-5-sonnet-20241022-v2:0) and Vertex @-versioned form (claude-3-5-sonnet-v2@20241022).
  • Env-var fallback: router.DefaultEnvVars is the global lookup table (OPENAI_API_KEY, ANTHROPIC_API_KEY, AWS_REGION, …). Mutate to customise per-tenant.
  • 4 typed errors: ErrEmptyModel, ErrUnsupportedRoute, ErrMissingCredentials, ErrNoAutoPlatform. Use errors.Is to discriminate. See the Router concept and API reference.

New providers/vertexanthropic

  • Claude on Google Vertex AI Model Garden. Endpoint: https://<region>-aiplatform.googleapis.com/v1/projects/<project>/locations/<region>/publishers/anthropic/models/<model>:streamRawPredict.
  • Pure HTTP — no google.golang.org/genai dependency. Bring your own token source.
  • Vertex-specific quirk handled: the anthropic_version: "vertex-2023-10-16" field is injected into the body (Vertex requires it in the body, not as a header).
  • Model id uses @-versioning: claude-3-5-sonnet-v2@20241022. Pass verbatim in ChatRequest.Model or use router.ApplyModelTranslation.
  • Auth: WithTokenSource(...) (preferred — supports refresh) or WithAccessToken(...) (static). Rejects llmrouter.WithAPIKey. See the provider page.

New providers/azureserverless

  • Generic provider for non-OpenAI / non-Claude models on Azure AI Foundry's Serverless API (MaaS) deployment mode. Covers Llama, Mistral, Cohere, Phi, Jais, Nemotron, DeepSeek.
  • Two URL shapes: deployment-scoped (https://<deploy>.<region>.models.ai.azure.com) and hub-scoped. Both via llmrouter.WithBaseURL.
  • No api-version query (gotcha versus azureopenai — copy-pasted URLs with ?api-version=... will 400).
  • Auth: llmrouter.WithAPIKey (sets the Azure-style api-key header) XOR azureserverless.WithAADToken. See the provider page.

Bug fixes

  • Deepgram decode (Issue #9) — some interim segments on Nova-3 streams were surfacing with empty Text. The decoder now handles the affected event shape.

Tests

  • ~127 new regression tests covering the router resolution matrix, the Vertex Anthropic body / SSE translation, the Azure Serverless URL composition and auth XOR, and the Deepgram decode regression.

Migration notes

  • v0.7 code runs unchanged. The router/ package is additive; existing callers that construct providers directly keep working.
  • Deepgram callers on streams that hit Issue #9 will start seeing populated Text on the previously empty interim segments. Re-test any downstream code that filtered empty-text segments as a workaround.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.8.0

v0.7.0 — 2026-05-17

Azure AI Foundry Anthropic, polished README, 10 examples, CONTRIBUTING, hardened CI.

The "make it usable" release. One new provider package fills the Claude gap on Azure AI Foundry; the README becomes the canonical install + capability-matrix surface; ten end-to-end examples land under examples/; CONTRIBUTING is added; and CI is hardened with race-clean runs and static-analysis gates.

New providers/azureanthropic

  • Claude on Azure AI Foundry. Body and SSE event stream are byte-identical to direct Anthropic — every capability of the direct provider works without code changes (typed tool use, thinking deltas, prompt cache, multipart, structured outputs, mid-stream errors, ToolResultMessage).
  • Two URL variants: deployment-scoped (/openai/deployments/<deployment>/messages) via WithDeployment(...), or resource-scoped (/openai/v1/messages) when no deployment is set. The model field in the body picks the variant in the resource-scoped path.
  • Mandatory WithAPIVersion(version) — the anthropic-version header is never sent; Foundry manages the API version via the query parameter.
  • Auth: llmrouter.WithAPIKey (Azure-style api-key header, not x-api-key) XOR azureanthropic.WithAADToken(src). Both — or neither — fails fast in New(). See the provider page.

Polished README + 10 examples + CONTRIBUTING

  • The canonical 22-provider capability matrix moves to the README so pkg.go.dev visitors see it without clicking through to the docs site.
  • Ten runnable examples under examples/ covering chat (OpenAI, Anthropic), embeddings, TTS, STT, realtime, rerank, structured outputs, and the new Azure Anthropic flow.
  • CONTRIBUTING.md documents the byte-passthrough contract, the provider-package conventions, and the table-driven test idioms the rest of the codebase uses.

CI hardening

  • Race-clean test runs on every PR (go test -race -count=1 ./...).
  • go vet + staticcheck gates.
  • Coverage tracking surfaced on the README badge.

Migration notes

  • v0.6 code runs unchanged. providers/azureanthropic is additive.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.7.0

v0.6.0 — 2026-05-16

STT event-type discriminator + SpeechFinal for voice-agent turn-taking.

A focused STT release. Streaming transcribers now distinguish transcript content from endpointing / metadata events, and voice-agent callers get a clean turn-taking signal that's independent of the per-window is_final marker.

New TranscriptSegment fields

  • Type string — populated verbatim from the upstream event name. Empty string is the default and means "transcript content"; non-empty values surface the upstream's discriminator (Deepgram: "Results", "SpeechStarted", "UtteranceEnd", "Metadata").
  • SpeechFinal bool — distinct from Final. Final is the upstream's per-window is_final; SpeechFinal is the end-of-utterance signal from VAD. Voice agents should dispatch turn-taking off SpeechFinal, not Final. See the audio concept.

Migration notes

  • Both fields default to the zero value — existing consumers that read Text, Final, Words keep working with no code changes.
  • Deepgram callers that previously dispatched voice-agent turn-taking off Final should switch to SpeechFinal. The previous behaviour was effectively wrong on long utterances — is_final fires several times within a single sentence as Deepgram freezes intermediate windows.
  • A separate Deepgram decode bug (Issue #9) that produced empty Text on some interim segments was discovered after v0.6 shipped and fixed in v0.8. Bump to v0.8 or later if you hit it.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.6.0

v0.5.0 — 2026-05-16

Gemini Live, Realtime tool use, structured outputs, Rerank, embeddings on Fireworks + DeepSeek.

The function-calling and RAG-refinement release. Five capability blocks land together: Google's full-duplex Gemini Live joins the realtime tier; OpenAI Realtime gets first-class tool use; structured outputs become a cross-vendor ChatRequest field; a brand-new Reranker interface closes the second-stage RAG gap; and Fireworks + DeepSeek complete the OpenAI-compat embedding coverage. Existing v0.4 code continues to work — the new surface is additive.

New top-level capability: Gemini Live

  • New package providers/geminilive — wraps Google's BidiGenerateContent WebSocket API. Mirror of openairealtime exactly: Provider.Connect(ctx, SessionConfig) (*Session, error) returning a handle with SendText, SendAudio, SendToolResult, Close, Events(), and Err().
  • SessionConfig fields: Model, Voice (one of Aoede, Charon, Fenrir, Kore, Puck), Instructions, OutputAudioFormat, Modalities, Temperature, TopP, Tools, Raw.
  • SessionEvent types: setup.complete, server.text, server.audio (with AudioMime), server.tool_call (with ToolCallID, ToolName, ToolArgs), server.turn_complete, error.
  • Sample-rate asymmetry surfaced in docs: input is 16 kHz PCM, output is 24 kHz PCM. One session per connection. See the Gemini Live provider page.

Tool use on OpenAI Realtime

  • SessionConfig.Tools and SessionConfig.ToolChoice — same llmrouter.ToolDef shape used by chat. No new tool schema for callers to learn.
  • New SessionEvent fields: ToolCallID, ToolName, ToolArgumentsDelta (incremental JSON args from response.function_call_arguments.delta), and ToolArguments (complete args from response.function_call_arguments.done).
  • New Session.SendToolResult(ctx, toolCallID, output) — replies to a tool call with the function output as a typed conversation.item.create frame. Function-calling is now first-class over the Realtime channel — no more dropping to Raw.

Structured outputs (JSON Schema)

  • New root type: llmrouter.ResponseSchema with Name, Description, Schema json.RawMessage, and Strict bool.
  • New field: ChatRequest.ResponseSchema *ResponseSchema. nil means “no constraint” (the existing behaviour).
  • Cross-vendor translation: OpenAI uses native response_format.json_schema; Anthropic translates to forced tool-use with a synthetic tool whose input_schema matches; Vertex and Gemini set GenerateContentConfig.ResponseMIMEType + ResponseSchema via the genai SDK. Other providers ignore the field. See the Structured outputs concept.

Rerank

  • New root interface: llmrouter.Reranker with Rerank(ctx, RerankRequest) (*RerankResponse, error).
  • New request / response types: RerankRequest (Model, Query, Documents, TopN, Raw), RerankResponse (Results, Usage, Raw), and RerankResult (Index, Score, Document). Results are sorted by descending score; Index joins back to the original document slice.
  • Implementations: Cohere (rerank-v3.5 and the v3.0 family), Voyage (rerank-2, rerank-2-lite), Together (Salesforce/Llama-Rank-V1). See the Rerank concept and API reference.

Embeddings extended to Fireworks + DeepSeek

  • Thin delegation through the OpenAI-compatible provider, with the right base URLs pre-configured. Completes the OpenAI-compat embedding coverage across the ten verified vendors — every OpenAI-compat provider that exposes an embedding endpoint now implements Embedder without extra work.

Capability matrix updates

  • New row: Gemini Live (session-based audio + text, tool use).
  • New column: Rerank (Cohere ✓, Voyage ✓, Together ✓).
  • New column: Structured outputs (OpenAI ✓, Anthropic ✓ via tool-use coercion, Vertex ✓, Gemini ✓).
  • Embed column extended: Fireworks ✓, DeepSeek ✓.

Tests

  • Subtest count grew from 1,742 to ~2,200. The new tests cover the Gemini Live state machine, the Realtime tool-call event translation, structured-output schema translation on three providers, and rerank request/response shapes on three providers.

Migration notes

  • v0.4 code runs unchanged. ResponseSchema defaults to nil; the new SessionConfig.Tools / SessionConfig.ToolChoice fields are additions, not replacements.
  • If you previously parsed Realtime tool-call events from SessionEvent.Raw, the typed ToolCallID / ToolName / ToolArgumentsDelta / ToolArguments fields are now populated alongside — the Raw escape hatch still works.
  • Anthropic structured-output callers must read the result from Choice.Delta.ToolCalls (forced tool-use), not from Choice.Delta.Content. The concept page shows the pattern.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.5.0

v0.4.0 — 2026-05-16

Realtime sessions, WebSocket streaming for audio, typed tool-result messages, Anthropic Voyage shim.

The realtime release. Existing audio providers gain WebSocket transports, OpenAI's full-duplex Realtime API gets its own top-level package, and the typed chat surface grows a proper tool-result message helper. Existing v0.3 code continues to work — the new surface is additive.

WebSocket streaming on existing providers

  • Deepgram live transcription — TranscribeRequest.Stream = true now opens a WebSocket against wss://api.deepgram.com/v1/listen. Interim and final segments stream back with per-word timing. TranscriptSegment.Final = false for interim results, true for the terminal segment per utterance.
  • Cartesia SpeakRealtime — new method SpeakRealtime(ctx, SpeechRequest) (*AudioStream, *RealtimeContext, error). The RealtimeContext handle exposes Append(text), Finalize(), and Close() for multi-turn TTS over a single socket. AudioStream behaves like the v0.3 streaming path on the consumer side.
  • ElevenLabs SpeakRealtime — identical signature, WebSocket TTS via /stream-input. Same RealtimeContext semantics — pick the vendor by voice quality / latency, not by API shape.

New top-level capability: OpenAI Realtime

  • New package providers/openairealtime — wraps the gpt-4o-realtime WebSocket API. Distinct from Provider / Speaker / Transcriber because the surface is session-based, not request-response.
  • Session lifecycle: Provider.Connect(ctx, SessionConfig) (*Session, error) then SendText, SendAudio, Commit, CreateResponse, UpdateSession, and Close. Events stream out of Session.Events() with the terminal error on Session.Err() — same lifecycle as Stream.
  • Full walkthroughs in the OpenAI Realtime provider page and the Realtime sessions concept page.

Typed tool-result messages

  • New helper: llmrouter.ToolResultMessage(toolCallID, content) returns a Message with Role: "tool" and the linkage fields set.
  • New Message fields: ToolCallID and Name, both omitempty. The existing Role + Content fields are unchanged.
  • Vendor wire translation: OpenAI passes the typed shape through directly; Anthropic translates a Role: "tool" message into a user-role message containing a tool_result content block, with tool_use_id derived from ToolCallID. Caller code is identical for both.

Anthropic + Voyage embeddings shim

  • New constructor: providers/anthropic.NewRecommendedEmbedder(voyageAPIKey string, opts ...llmrouter.Option) (llmrouter.Embedder, error). Returns a Voyage-backed Embedder so calling code can ask the Anthropic package for embeddings without knowing about Voyage.
  • Codifies Anthropic's documented recommendation that Claude users embed with Voyage. The Anthropic provider itself still does not implement Embedder; this is a convenience shim, not a wire-level wrapper.

Dependencies and tests

  • New dependency: github.com/coder/websocket v1.8.14 — pure-Go, no cgo, no transitive churn.
  • Subtest count grew from 1,592 to 1,742. The new tests cover the WebSocket framing for Deepgram, Cartesia, and ElevenLabs, the Realtime session state machine, the tool-result translation for both vendors, and the Voyage shim.

Migration notes

  • v0.3 code runs unchanged. The new methods are additions; no existing signatures changed.
  • If you previously sent tool results as a hand-rolled Message{Role: "tool", Content: ...}, that still works — but ToolResultMessage wires ToolCallID in the right place for Anthropic automatically.
  • Deepgram streaming behaviour changes: Stream=true used to be a no-op, now it opens a WebSocket. Code that set Stream=true on Deepgram and got the single-final-segment fallback will now receive interim segments.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.4.0

v0.3.0 — 2026-05-15

Audio, embeddings, and four new specialist providers.

The biggest single release since v0.1. llmrouter grows beyond chat: three new root capabilities (Embeddings, TTS, STT) and four new provider packages dedicated to audio and embeddings. Existing chat code is unchanged — the new interfaces live alongside Provider.

New root capabilities

  • llmrouter.Embedder interface — Embed(ctx, EmbedRequest) (*EmbedResponse, error). Documented at Embeddings concept and API reference.
  • llmrouter.Speaker interface (TTS) — Speak(ctx, SpeechRequest) (*AudioStream, error).
  • llmrouter.Transcriber interface (STT) — Transcribe(ctx, TranscribeRequest) (*TranscriptStream, error). Documented at Audio concept and API reference.
  • AudioStream / TranscriptStream with the same single-consumer, context-cancellation, terminal-error lifecycle as Stream. New types: AudioChunk, TranscriptSegment, TranscriptWord, SpeechRequest, TranscribeRequest, EmbedRequest, EmbedResponse.
  • Cross-vendor format normalisation: audio formats (mp3 / opus / wav / pcm / ulaw) and embedding task types (Vertex canonical → Cohere / Voyage / OpenAI translations).

New providers

  • ElevenLabs — TTS via the Eleven family (eleven_turbo_v2_5, eleven_multilingual_v2, eleven_flash_v2_5) and STT via Scribe (scribe_v1). No chat.
  • Deepgram — STT only. Nova-3, Nova-2, enhanced, with per-word timing, confidence scores, and diarization via Raw. WebSocket streaming on v0.4 roadmap.
  • Cartesia — TTS only. Sonic-2 with sub-100 ms first-token latency, SSE streaming. WebSocket streaming on v0.4 roadmap.
  • Voyage AI — Embeddings only. voyage-3 / voyage-3-large / voyage-code-3 / voyage-finance-2 / voyage-multilingual-2. Recommended pairing for Anthropic Claude.

Capability matrix updates for existing providers

  • OpenAI now implements Embedder, Speaker (TTS), and Transcriber (Whisper) in addition to Provider.
  • Azure OpenAI matches OpenAI for all four capabilities (each requires a separate deployment).
  • AWS Bedrock adds embeddings via Titan and Cohere on Bedrock.
  • Vertex AI adds embeddings (text-embedding-005) and partial TTS via the Gemini path.
  • Gemini (AI Studio) adds embeddings, TTS, and STT via audio understanding — the only chat-first provider with all four capabilities.
  • Cohere adds Embed v3 embeddings with mandatory input_type derived from TaskType.
  • Mistral adds mistral-embed.
  • Together adds delegated embeddings.
  • Groq adds Whisper STT.

Known limitations

  • Deepgram and Cartesia have HTTP/SSE paths today; WebSocket streaming lands in v0.4.
  • Anthropic does not offer first-party embeddings. llmrouter recommends pairing with Voyage AI; when Anthropic ships embeddings, the provider will gain Embedder.
  • Bedrock TTS (Polly) and STT (Transcribe) are not wrapped; use ElevenLabs / Cartesia / Deepgram for those.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.3.0

v0.2.0 — 2026-05-15

Cloud triple, tool use, multimodal, ten OpenAI-compatible providers verified.

The cloud-provider release. Adds the three managed cloud LLM endpoints (Azure OpenAI, AWS Bedrock, Google Vertex), plus direct-API providers for Gemini, Cohere, and Mistral. Closes the typed surface around features that previously rode on Raw (tool use, multimodal, prompt caching).

New providers

  • Azure OpenAI Service — deployment-scoped URL, api-key header, api-version query parameter. Chat + embeddings + TTS + Whisper STT (each via its own deployment).
  • AWS Bedrock — SigV4 signing, per-model-family body translation for Claude, Llama, Titan, Nova, Mistral, and Cohere on Bedrock.
  • Google Vertex AI — ADC auth, project/region scoping, Gemini and Claude chat, embeddings, partial TTS.
  • Google Gemini (AI Studio) — API-key-based direct API.
  • Cohere — Command family chat + Embed v3.
  • Mistral — chat + mistral-embed.
  • Ten OpenAI-compatible providers verified: OpenRouter, Together, Groq, DeepSeek, Fireworks, xAI (Grok), Perplexity, Cerebras, vLLM, Ollama. All share the OpenAI provider machinery via WithBaseURL.

API additions

  • Typed tool-call passthrough: ChatRequest.Tools []ToolDef on the way out and Choice.Delta.ToolCalls on the way back, with full translation to Anthropic tool_use / tool_result. Closes #1.
  • Extended thinking: Claude 3.7+ thinking blocks surfaced via Choice.Delta.Thinking.
  • Prompt caching: Message.CacheControl for Anthropic ephemeral cache; Usage.CachedTokens populated for OpenAI auto-cache.
  • Multimodal content helpers: llmrouter.ImageURLContent and ImageBytesContent. Closes #2.
  • Mid-stream error surfacing: SSE-delivered error events arriving after the stream opened are now surfaced via Stream.Err() instead of silent EOF.

Migration notes

  • WithExtra is now a typed map per provider; if you stored Azure deployment / Vertex project / Bedrock region there, switch to the dedicated azureopenai.WithDeployment, vertex.WithProject, bedrock.WithRegion helpers.
  • Choice.Delta.Content remains a string for typed callers; tool calls now arrive on Choice.Delta.ToolCalls. Application code that previously parsed tool calls from Chunk.Raw continues to work.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.2.0

v0.1.1 — 2026-05-15

Tests / coverage. No source or API changes.

A pure-quality release. v0.1.0 application code runs unchanged on v0.1.1 — there is no migration to do, and you can bump safely.

  • Added a 330-subtest table-driven test suite spanning the root package, both providers, the option pattern, the streaming producer, and the error wrapper.
  • 100% statement coverage on the root package (llmrouter.go, options.go, stream.go, errors.go).
  • 90.4% statement coverage on each provider package. The uncovered branches are non-2xx-with-fixture HTTP error paths that need full upstream HTTP fixtures — those land in a separate provider integration suite later.
  • All tests run race-clean (go test -race -count=1 ./...).
  • No public-API changes. No new dependencies. No behaviour changes.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.1.1

v0.1.0 — 2026-05-15

Initial public release.

First tagged release of the library. Establishes the core surface (the Provider interface, the ChatRequest/Chunk types, the Stream handle, the option pattern, the ErrUpstream wrapper) and ships the first two providers.

Core API

  • llmrouter.Provider interface — minimal surface of Name() and CompletionStream(ctx, ChatRequest) (*Stream, error). One method, one shape; everything else lives on the request and response types.
  • llmrouter.ChatRequest — OpenAI-shaped request body with a Raw json.RawMessage escape hatch for byte passthrough.
  • llmrouter.Message with llmrouter.TextMessage constructor; multimodal content is sent via the raw Content json.RawMessage field.
  • llmrouter.Stream handle with Chunks() receive channel, Err() terminal error, and Cancel() convenience cancel.
  • llmrouter.Chunk with normalised OpenAI-shaped Choices, optional Usage, and a Raw json.RawMessage with the original wire-format event for byte-level passthrough.
  • Option pattern: WithAPIKey, WithBaseURL, WithHTTPClient, WithTimeout, WithExtra.
  • llmrouter.ErrUpstream error wrapping non-2xx responses with Provider, StatusCode, and the raw response Body.

OpenAI provider

  • Streaming chat completions against /v1/chat/completions with SSE.
  • WithBaseURL override that turns the OpenAI provider into a universal OpenAI-compatible client — works out of the box with OpenRouter, Together, Groq, vLLM, Ollama, LM Studio, and any other endpoint that speaks the OpenAI SSE shape.
  • Byte passthrough on requests (ChatRequest.Raw) and on chunks (Chunk.Raw) so a proxy can forward bytes unchanged.

Anthropic provider

  • Full request translation: OpenAI messages array → Anthropic /v1/messages body, including lifting the system role into Anthropic’s top-level system field and translating the content block shape.
  • Full SSE event translation: Anthropic’s message_start, content_block_delta, message_delta, and message_stop events → OpenAI-shaped delta Chunks. Your consumer loop sees the same structure regardless of which provider is upstream.
  • MaxTokens is required on the request (Anthropic rejects requests without it); see the quickstart for the canonical example.

Streaming semantics

  • Producer goroutine pushes Chunk values into a buffered channel; the single consumer reads with range stream.Chunks() until close.
  • context.Context cancellation propagates from the caller all the way to the in-flight HTTP request — cancelling the context closes the upstream connection and unwinds the producer.
  • stream.Cancel() is equivalent to cancelling the context: safe to call multiple times, safe to call before or after the consumer drains.
  • stream.Err() returns the terminal error after the channel closes; blocks until the producer finishes; returns nil on a clean stream.

Known limitations (at v0.1.0 release)

All of these have since been addressed in subsequent releases:

  • No Azure / Bedrock / Vertex provider — landed in v0.2.0.
  • No typed tool-call surface — landed in v0.2.0.
  • No embeddings API — landed in v0.3.0.
  • No audio (TTS / STT) — landed in v0.3.0.
  • Pre-1.0 — still applies; expect minor breakages between minor versions.

Release link: github.com/elloloop/llmrouter/releases/tag/v0.1.0

Future versions

Future versions are appended at the top of this page as they ship. The roadmap describes what is planned for v0.9 (Vertex-native vertexllama / vertexmistral / vertexcohere, batch APIs, OpenAI Files + Assistants v2, gpt-4o-audio in chat), v0.10 (prompt management, semantic caching), and v1.0 (API freeze).

For commit-by-commit detail and signed release artifacts, see the full GitHub Releases page.