Changes for version 0.402 - 2026-04-20

  • [BREAKING] Langertha::Engine::MiniMax now talks to MiniMax's native OpenAI-compatible endpoint (https://api.minimax.io/v1) instead of the Anthropic-compatible shim. The previous behavior is preserved as a new class Langertha::Engine::MiniMaxAnthropic (URL corrected to /anthropic/v1 as MiniMax actually documents). Background: MiniMax's /anthropic endpoint does not reliably re-parse stringified tool-call arguments, causing intermittent tool-calling failures where the Anthropic SDK sees a wrapper object whose key rotates between 'result', 'arguments', and the tool name. MiniMax's native OpenAI endpoint avoids the shim entirely. Users who need the Anthropic wire format should switch from Langertha::Engine::MiniMax to Langertha::Engine::MiniMaxAnthropic. The default model is now MiniMax-M2.7 (was MiniMax-M2.5) on both classes.
  • Automatic tool_choice normalization. chat_request in OpenAICompatible and AnthropicBase now runs any tool_choice passed via %extra through Langertha::ToolChoice and emits the target-engine's native format. Callers can pass Anthropic-style (type+name), OpenAI-style (type:function + function.name), or string shorthands ('auto', 'none', 'required', 'any') to any engine — no more engine-specific branching needed.
  • New Langertha::Role::ParallelToolUse with a canonical `parallel_tool_use` boolean attribute. Constructor also accepts the provider-native alias names: `parallel_tool_calls` (OpenAI) and `disable_parallel_tool_use` (Anthropic, inverted). The attribute is translated per-engine to the native request parameter — OpenAI sends `parallel_tool_calls`, Anthropic folds `disable_parallel_tool_use` into the tool_choice block. Automatically composed by Langertha::Role::Tools so every tool-capable engine gets it.
  • Langertha::ToolChoice accepts 'any' as a string shorthand and {type:'required'} as a hash form (both normalize to canonical type 'any').
  • Added MiniMax-M2.7 to the static model list and made it the default.

Documentation

Simple chat with Ollama
Simple chat with OpenAI
Simple script to check the model list on an OpenAI compatible API
Simple transcription with a Whisper compatible server or OpenAI

Modules

The clan of fierce vikings with 🪓 and 🛡️ to AId your rAId
Chat abstraction wrapping an engine with optional overrides
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 OpenAI-compatible API
Base class for Anthropic-compatible engines
Cerebras Inference API
Google Gemini API
GroqCloud API
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)
Nous Research Inference API
Ollama via OpenAI-compatible API
Base class for OpenAI-compatible engines
Perplexity Sonar API
Base class for all remote engines
SGLang inference server
Whisper compatible transcription server
vLLM inference server
Image generation abstraction wrapping an engine with optional overrides
Request input transformation helpers
Backwards-compat facade over Langertha::Tool / Langertha::ToolChoice
Backwards-compat facade over Langertha::Usage / Pricing / Cost / UsageRecord
Response output transformation helpers
Backwards-compat facade over Langertha::ToolCall
Base class for plugins
Langfuse observability plugin for any PluginHost
Model→price catalog producing Langertha::Cost from Langertha::Usage
Base class for orchestrating Runnable steps
Looping Raid orchestrator
Parallel Raid orchestrator with branched context isolation
Sequential Raid orchestrator
Autonomous agent with conversation history and MCP tools
Result object from a Raider raid
Rate limit information from API response headers
A HTTP Request inside of Langertha
LLM response with metadata
Common result object for Raider and Raid execution
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 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 where you can specify structured output
Role for an engine where you can specify the response size (in tokens)
Common async execution contract for Raider and Raid nodes
Role for an engine that can set a seed
Role for engines with a hardcoded model list
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 MCP tool calling support
Role for APIs with transcription functionality
Shared execution context for Raid and Raider runs
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 value object for LLM token usage with cross-provider conversion
Tagged ledger entry combining Usage, Cost, and request metadata
Bring your own viking!