Changes for version 0.305 - 2026-03-08
- New engine base class: Langertha::Engine::AnthropicBase for Anthropic-compatible APIs (shared /v1/messages chat/streaming/tool/model handling and Anthropic rate-limit parsing). Anthropic now extends this base, and MiniMax + LMStudioAnthropic were migrated to extend it too.
- New engine: Langertha::Engine::LMStudio — native LM Studio local REST API adapter (POST /api/v1/chat, SSE streaming with message.delta/chat.end, GET /api/v1/models). Supports optional bearer auth via LANGERTHA_LMSTUDIO_API_KEY, plus basic auth via URL userinfo. Includes openai() helper returning a Langertha::Engine::LMStudioOpenAI instance for LM Studio's /v1 endpoint.
- New engine: Langertha::Engine::LMStudioOpenAI for LM Studio's OpenAI-compatible /v1 endpoint (defaults api_key to C<lmstudio>).
- New engine: Langertha::Engine::LMStudioAnthropic for LM Studio's Anthropic-compatible /v1/messages endpoint. Includes LMStudio->anthropic helper for easy conversion from native engine instances; defaults api_key to C<lmstudio>.
- New OpenAPI spec: share/lmstudio.yaml with operationIds for LM Studio native chat and model listing, plus Langertha::Spec::LMStudio for pre-computed operation lookup.
- Tests: extend t/00_load.t, t/10_engine_hierarchy.t, and t/11_basic_auth.t to cover LMStudio loading, inheritance/roles, request mapping, and auth behavior. Extend t/83_live_chat.t with optional LM Studio live coverage via TEST_LANGERTHA_LMSTUDIO_URL, TEST_LANGERTHA_LMSTUDIO_MODEL, and TEST_LANGERTHA_LMSTUDIO_API_KEY.
- Documentation: add POD for LMStudio, LMStudioOpenAI, and LMStudioAnthropic helpers/attributes and expand README examples to include explicit LMStudioOpenAI/LMStudioAnthropic class usage.
- Orchestration foundation on top of Raider: add Langertha::Role::Runnable (run_f contract), Langertha::RunContext (input/state/artifacts/metadata/trace + branch/merge), Langertha::Raid base class, and concrete orchestrators Langertha::Raid::Sequential, Langertha::Raid::Parallel, Langertha::Raid::Loop. Supports nested composition of Raider and Raid nodes.
- Unified result model: add Langertha::Result as common result abstraction (final/question/pause/abort), and make Langertha::Raider::Result a backward-compatible subclass so Raider and Raid share the same result semantics.
- Raider compatibility + interface: Raider now composes Langertha::Role::Runnable and exposes run_f($ctx) as an orchestration-friendly wrapper around raid_f while keeping existing public raid_f/respond_f behavior intact.
- Raider fixes: _gather_tools_f now uses the active engine (not always the default engine), and Langfuse model parameters are recalculated after engine/tool dirtiness refresh during runtime engine switching.
- Raider respond_f consistency: plugin_after_tool_call hooks are now applied to remaining tool calls during continuation flow (self-tools and MCP tools), matching main loop behavior.
- Tests: add t/96_raid_orchestration.t covering Runnable compatibility, sequential/ parallel/loop orchestration, nested Raid trees, context propagation and parallel isolation/merge semantics, result propagation (final/question/pause/abort), and error paths for all orchestrator types. Extend t/00_load.t to include new modules.
- Documentation: add inline POD for all new orchestration/result/context modules and refresh Raider::Result POD to reflect shared result inheritance. Extend README with a new "Raid — Workflow Orchestration" section (RunContext, Sequential/Parallel/Loop, unified results, nesting), plus a top-level table of contents, architecture overview, and a minimal sequential orchestration example.
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
Embedding abstraction wrapping an engine with optional model override
AKI.IO native 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
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 (Anthropic-compatible)
Mistral API
Nous Research Inference API
Ollama API
Ollama via OpenAI-compatible API
OpenAI API
Base class for OpenAI-compatible engines
OpenRouter API
Perplexity Sonar API
Base class for all remote engines
Replicate API
Whisper compatible transcription server
vLLM inference server
Image generation abstraction wrapping an engine with optional overrides
Base class for plugins
Langfuse observability plugin for any PluginHost
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 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
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