Process a batch of prompts with MLX-based batch inference This method provides true batch processing for MLX models, process

Implement the RE2 (Re-Reading) approach for improved reasoning in LLMs. Args: system_prompt (str): The system prompt to be used. ini

Set a specific adapter as active with error handling

Synchronous wrapper for solve_async method.

Update the token history with new tokens. Args: new_tokens: New token IDs to add

Validate and normalize DeepConf configuration. Args: config: Input configuration dictionary Returns: Valida

Apply a steering vector to hidden states. Args: hidden_states: The hidden states tensor steering_vec

Clean up caches if they exceed max size.

Clean up steering hooks.

Create stopping criteria for generation

Execute a handler function with proper signature detection

Extract the final answer from the response.

Extract content from <think> tags.

Filter out OptiLLM-specific parameters that shouldn't be sent to providers

Create a valid adapter name from adapter_id.

Get UTF-8 bytes for a token

Get the log file path for a given timestamp (defaults to now)

Generate a summary of all verification results

Implements linear attention for more memory efficiency

Robust MLX generation using sampler approach

Add a reasoning example to the strategy.

Add a new token's confidence and update group statistics. Args: logits: Raw logits tensor for current token posi

Add confidence statistics from a warmup trace. Args: confidence_stats: Dictionary with confidence metrics

Analyze token probability distributions and entropy patterns. Args: logprobs_data: List of dictionaries containing token and log

Main plugin execution function with AutoThink's controlled thinking process. Args: model: Language model tokenizer: Mode

Calculate the confidence threshold based on warmup traces. Args: metric: Which confidence metric to use for thre

Calculate token confidence: C = -(1/k) ∑log P(j) for top-k tokens Args: logits: Raw logits tensor for current to

Applies CePO reasoning flow for the given task. First, it generates multiple completions, and then rates them to select the best one. Each co

Clean text by removing extra whitespace and normalizing newlines

Remove any remaining placeholder tags from the final report. This is a final cleanup step to ensure no incomplete research tags remain

Connect using stdio transport with local executable

Connect to server using WebSocket transport and discover capabilities

Create a default configuration file if none exists

Execute Python code in a Jupyter notebook environment.

Execute tool using SSE transport

Execute tool using WebSocket transport

Extract Python code blocks from text.

Extract numerical answer after ### from GSM8K responses.

We noticed that sometimes if the task includes specific formatting instructions, they may interfere with the reasoning flow. This is a tempor

Find the full path to an executable command. Args: cmd: The command to find Returns: Full path to the execu

Find a strategy of the same problem type that is similar to the query. Args: problem_type: The problem type to m

Generate a single reasoning trace with optional early termination. Args: messages: Input messages us

Get a description of all capabilities

Get the captured log output

Get the most recent group confidence. Returns: Most recent group confidence or None if not available

Alternative way to get the singleton instance.

Get or load model and tokenizer with minimal locking.

Get problem data by ID

Get simple test messages for basic validation

Get test messages that should generate thinking tokens

Get tools in a format suitable for the model's tool-calling API

Get comprehensive confidence statistics for the current trace. Returns: Dictionary with various confidence metri

Try to handle the given name as an approach or plugin. Returns None if not found, otherwise returns (response, tokens)

Check if we have enough verified solutions to reach consensus

Check if browser session is active

Return list of supported models

Load and parse SimpleQA dataset

Repeatedly calls a function until its output matches one of the given patterns or max attempts is reached. Args: function (Callable)

Main evaluation function that handles gaps in processed indexes.

Executes a MapReduce-style inference pipeline to answer a query from long context. The function splits the input context into chunks, summar

Measure time for batch processing

Measure time for sequential processing

Normalize answer for comparison

Helper function to normalize interval bounds.

Helper function to normalize a single matrix entry.

Convert JSON schema string to Pydantic model.

Perform web search for multiple queries using the web_search plugin

Predict the complexity label for a given text. Args: text: The query text to classify Retur

Process messages with AutoThink's controlled thinking. Args: messages: List of message dictionaries

Filter out chunks that contain at least one of irrelevance tags.