Changes for version 0.505 - 2026-11-05
- New reasoning_wire_format chat_template_kwargs: sends chat_template_kwargs.enable_thinking (a JSON boolean) plus reasoning_effort, and only enable_thinking false for effort none. It is the default on LlamaCpp and SGLang, and any OpenAI-compatible engine takes it through the constructor. A chat_template_kwargs hash the caller passes in %extra is merged one level deep; the caller's keys win (ADR 0040).
- New tri-state thinking_enabled control (engine attribute and chat_f control) next to reasoning_effort: on, off, or unset. A per-request value replaces both engine values; a contradiction inside one layer croaks, at construction too. Ollama native honors a per-request thinking_enabled.
- DeepSeek V3.x with reasoning effort none or thinking off sends thinking {type: disabled}; it sent enabled before. The OpenAI temperature gate reads the resolved effort.
- Fix constructing an engine or a plugin from one hash reference: new({ ... }) now takes every argument, the same as new( ... ), and warns nothing. This covers every chat engine (through Langertha::Role::Langfuse) and Langertha::Plugin; the LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY defaults and the raider alias for host apply to both forms.
- ex/raider_rag.pl defaults to a local Ollama at http://localhost:11434, like the other examples.
Documentation
Simple chat with Ollama
Simple chat with OpenAI
Generate images through OpenAI or an explicit subscription proxy
Simple script to check the model list on an OpenAI compatible API
Simple transcription with a Whisper compatible server or OpenAI
Wire contract for self-hosted inference engine /metrics endpoints
Modules
The clan of fierce vikings with axes and shields to AId your rAId
Immutable value object for a Gemini explicit cachedContent resource
Result of an embedding, transcription or image call, with usage, rate limit and timing
Chat abstraction wrapping an engine with optional overrides
Base role for canonical multimodal content blocks with cross-provider serialization
Canonical image content block with cross-provider conversion
Immutable value object for the monetary cost of a single LLM call
Embedding abstraction wrapping an engine with optional model override
AKI.IO native API
AKI.IO via Anthropic-compatible API
AKI.IO via OpenAI-compatible API
Anthropic API
Base class for Anthropic-compatible engines
Cerebras Inference API
DeepSeek API
Google Gemini API
GroqCloud API
Hetzner Inference API (OpenAI-compatible)
HuggingFace Inference Providers API
LM Studio native REST API
LM Studio via Anthropic-compatible API
LM Studio via OpenAI-compatible API
llama.cpp server
MiniMax API (OpenAI-compatible)
MiniMax API via Anthropic-compatible endpoint (legacy)
Mistral API
Langertha::Engine::Virtual under the engine name Mock
Moonshot AI Kimi API (OpenAI-compatible)
Moonshot AI Kimi API via Anthropic-compatible endpoint
Nous Research Inference API
Ollama API
Ollama via OpenAI-compatible API
OpenAI API
Base class for OpenAI-compatible engines
OpenAI Responses API (reasoning models like gpt-5.5-pro)
OpenRouter API
Perplexity Agent API (search-augmented)
Base class for all remote engines
Replicate API
SGLang inference server
Scaleway Generative APIs
T-Systems AI Foundation Services (LLM Hub)
Base class for OpenAI-compatible transcription-only engines
vLLM inference server with vLLM-Hook probe capture
Rule-driven engine that answers without network, key or model
Whisper compatible transcription server
xAI Grok API
vLLM inference server
Bounded Content-Encoding inflate shared by the response-body decoders
Check that the modules Net::Async::HTTP loads at connect time load
The redirect policy both HTTP backends follow: credentials stay on their origin
LWP::UserAgent that keeps credentials on their origin across redirects
Image generation abstraction wrapping an engine with optional overrides
Request input transformation helpers
Backwards-compat facade over Langertha::Tool / Langertha::ToolChoice
Provider manifest (/.well-known/langertha.json) value object, parser and validator
One auth mechanism of a provider manifest (type only, never a secret)
Build a provider manifest from configured engines (offline, never copies a secret)
One endpoint of a provider manifest: wire dialect, base URL, auth reference
One model entry of a provider manifest: id, endpoint, declared capabilities
Internal validation rules shared by the provider manifest value objects
DEPRECATED back-compat facade over Langertha::Usage / Pricing / Cost / UsageRecord - use the value objects directly
Reads model-scoped capability facts from a provider's own model metadata
Instant on the wire - a Time::Moment that numifies to its Unix epoch
Response output transformation helpers
Backwards-compat facade over Langertha::ToolCall
Base class for plugins
Langfuse observability plugin for any PluginHost
Model-to-price catalog producing Langertha::Cost from Langertha::Usage
Immutable prompt-caching request control with cross-provider conversion
Rate limit information from API response headers
Immutable normalized reasoning-effort control with cross-provider conversion
Invented level<->token-budget interpolation, clamped to a Profile's enforced bounds
Typed per-model reasoning wire-truth (accepted vocabulary + numeric bounds)
A HTTP Request inside of Langertha
Synchronous LWP-backed HTTP client satisfying the async do_request contract
LLM response with metadata
Reserved namespace - the result value object moved to Langertha::Raider::Result
Role for Anthropic-compatible API format
Async HTTP backend selection (injected > Net::Async::HTTP > sync LWP fallback)
Role for the explicit cachedContent resource lifecycle (create/get/list/update/delete)
Engine-capability registry derived from composed roles
Role for APIs with normal chat functionality
Role for an engine where you can specify the context size (in tokens)
Role for APIs with embedding functionality
Role for HTTP APIs
Hermes-style tool calling via XML tags
Role for engines that support image generation
Role for an engine whose wire can carry image input
Role for JSON
Role for engines that support keep-alive duration
Langfuse observability integration
Role for APIs with several models
Role for OpenAI-compatible API format
Role for APIs with OpenAPI definition
Role for an engine that supports parallel tool calling control
Role for objects that host plugins (Raider, Engine)
Role for an engine with a request-side prompt-caching control
Role for an engine with a request-side reasoning-effort control
Role for an engine where you can specify structured output
Role for an engine where you can specify the response size (in tokens)
Role for the Open-Responses wire envelope (input/instructions/output[])
Common async execution contract (run_f) for runnable nodes
Async Prometheus /metrics scraper for self-hosted engines
Role for a self-hosted engine with per-request prefix-cache runtime knobs
Role for an engine that can set a seed
Role for an engine whose wire accepts provider-native server-side tools
Role for engines with a hardcoded model list
Role for an engine whose stream request asks for the token usage
Role for streaming support
Role for APIs with system prompt
Role for an engine that can have a temperature setting
Configurable think tag filtering for reasoning models
Role for an engine whose tool results carry images the model sees
Role for an engine whose tool results carry PDFs the model reads
Role for MCP tool calling support
Role for APIs with transcription functionality
Structured, dependency-free execution context for runnable nodes
Immutable self-hosted runtime knobs with per-server conversion
Prometheus text exposition format parser with prefix filter
Convert parsed Prometheus records to an OTLP/HTTP (JSON) metrics payload
Provider-native server-side tool definition, pinned to one wire format
Record of one tool call the provider executed itself
Pre-computed OpenAPI operations for LM Studio native API
Pre-computed OpenAPI operations for Mistral
Pre-computed OpenAPI operations for Ollama
Pre-computed OpenAPI operations for OpenAI
Iterator for streaming responses
Represents a single chunk from a streaming response
Immutable canonical tool definition with cross-provider format conversion
Immutable canonical tool invocation emitted by an LLM
Immutable canonical tool-selection policy with cross-provider conversion
Immutable canonical result of executing one tool, with cross-provider conversion
Immutable value object for LLM token usage with cross-provider conversion
Tagged ledger entry combining Usage, Cost, and request metadata
Loader for vLLM-Hook model_configs/*.json files
Helpers that build the rules of Langertha::Engine::Virtual
HTTP endpoint in front of a Langertha::Engine::Virtual
Bring your own viking!
Examples
- ex/async_await.pl
- ex/ctx.pl
- ex/embedding.pl
- ex/hermes_tools.pl
- ex/ircbot.pl
- ex/json_grammar.pl
- ex/langfuse-k8s.yaml
- ex/langfuse.pl
- ex/logic.pl
- ex/mcp_inprocess.pl
- ex/mcp_stdio.pl
- ex/ollama.pl
- ex/ollama_image.pl
- ex/raider.pl
- ex/raider_plugin_sugar.pl
- ex/raider_rag.pl
- ex/raider_run.pl
- ex/response.pl
- ex/sample.ogg
- ex/streaming_anthropic.pl
- ex/streaming_callback.pl
- ex/streaming_future.pl
- ex/streaming_gemini.pl
- ex/streaming_iterator.pl
- ex/streaming_mojo.pl
- ex/structured_code.pl
- ex/structured_output.pl
- ex/structured_sentences.pl
- ex/synopsis.pl
- ex/transcription.pl