Reset processor state for new query.

Reset the hook state for a new generation.

Set the global logger instance (called by optillm.py)

Determine if a model should use MLX instead of PyTorch

Splits long text into granular, token-length-constrained chunks using sentence boundaries. Sentences are first extracted using a delimiter p

Splits text into sentences or segments based on a given delimiter while preserving punctuation. For punctuation-based splitters (e.g., ".",

Stop the test server

Try to match the current context with a steering vector. Only allows one pattern to be selected for the entire generation. Tr

Update the context buffer with new tokens. Args: new_tokens: New tokens to add to the context.

Validate that the research report is complete and ready for publication. Checks for: - Placeholder citations - Incomplete sectio

Run comprehensive verification on all solutions in workspace with parallel execution

ADAPT: Rephrase modules to be more task-specific.

Apply sensible defaults to configuration. Args: config: Configuration dictionary Returns:

Assign temperature based on agent ID for 3-agent configuration

Calculate consistency of final answers.

Calculate consistency of reasoning processes.

Check if OptILLM server is already running

Check health of a single provider

Check if server is healthy

Classify the problem type for strategy matching

Clean up the final response.

Clean up sessions older than max_session_age.

Compute token distribution entropy

Count strategies by problem type

Create and start a batch processor thread for a specific queue Args: queue_key: The key identifying the queue/mo

Create default configuration file.

Create an enhanced prompt that incorporates the reasoning structure.

Create the internal processor instance.

Detect the type of client based on class name

Discover built-in approaches from optillm package

Discover available approaches and plugins dynamically

Discover available plugins dynamically

Ensure we have minimum population size for effective aggregation

Estimate confidence based on solution characteristics

Evaluate confidence based on consistency across samples. Returns a confidence score between 0 and 1.

Extract AIME-style numeric answers (integers 0-999)

General fallback answer extraction patterns

Extract answers for specific IMO 2025 problems

Extract the query from messages for classification. Args: messages: List of message dictionaries

Extract strategy from a single agent solution

Extract a task description for SELF-DISCOVER from the query and system prompt.

Find optimal batch size through binary search with memory monitoring

Format messages based on whether the model supports system messages.

Format messages based on provider's system message support

Generate new solutions by aggregating sampled solutions in parallel

Generate a single greedy sample with temperature=0.

Generate multiple samples by calling the API multiple times.

Generate a unique request ID

Generate enhanced solution using peer strategies

Get most effective strategies for the given problem type

Get overall effectiveness statistics

Get the last index for a given entity type.

Return minimal working config as fallback.

Get most effective strategies across all problem types

Generate key to group compatible requests Args: request_data: The request data dictionary R

Get cached system message support status, testing if not cached. Thread-safe with locking.

Calculate top alternative tokens and their logprobs

IMPLEMENT: Create a structured reasoning plan in JSON format.

Recursively replace ${VAR} and ${VAR:-default} with environment values. Args: obj: Object to process (dict, list

Load strategies and metrics from disk.

Load MLX model and tokenizer with caching

Load the classification model using adaptive-classifier library.

Log comprehensive overview of all solutions before synthesis

Create response based on majority vote of answers and best reasoning.

Make a request with timeout handling

Merge two similar strategies into one.

Normalize math-verify result to appropriate format

Parse and validate configuration parameters.

Parse explicit set like '0, 1, 3

Parse JSON structure with robust error handling and cleanup.

Parse set notation with ellipsis like '0, 1, 2, ..., n

Parse structured strategy analysis response

Parse verification result to extract structured information

Process a batch of requests Args: batch: List of batch requests to process

Process a dataset item into a steering vector. Args: item: Dataset item Returns:

Run the multi-agent exploration phase with parallel execution

Async implementation of MARS with parallel execution

Run a single aggregation loop: sample K -> aggregate -> update population

Sample K solutions from population for aggregation Uses different strategies for each sample to maintain diversity

SELECT: Choose relevant reasoning modules for the task.

Select an agent different from the solution creator for verification

Set up steering vector management.

Start server with conversation logging enabled

Synthesize the final solution from all agent outputs and verifications

Test if a model supports system messages by making a minimal test request. Returns True if supported, False otherwise.

Test if a model supports system messages

Try to extract answer using math-verify library

Try to match using text-based context (original approach).

Try to match using token-based context (similar to guided mode).

Update group confidence based on current sliding window.

Update population with new solutions, maintaining population size limit

Validate that all requests in batch are compatible Args: requests: List of batch requests R

Validate configuration structure and values. Args: config: Configuration to validate Return