⚡️ Speed up method CohereChatConfig.map_openai_params by 75%

[codeflash-ai]

📄 75% (0.75x) speedup for CohereChatConfig.map_openai_params in litellm/llms/cohere/chat/transformation.py

⏱️ Runtime : 198 microseconds → 113 microseconds (best of 329 runs)

📝 Explanation and details

The optimization replaces sequential if statement chains with a single dictionary lookup, dramatically reducing computational overhead in the map_openai_params method.

Key Changes:

• Dictionary-based parameter mapping: Instead of 11 sequential if param == "..." checks for each parameter, the code now uses a param_map dictionary and performs a single if param in param_map check followed by direct lookup.
• Reduced string comparisons: The original code performed up to 11 string equality comparisons per parameter (worst case), while the optimized version performs just one dictionary membership test.

Why This Is Faster:

• O(1) vs O(n) lookup: Dictionary membership testing (in param_map) is O(1) average case, while sequential string comparisons are O(n) where n is the number of supported parameters.
• Branch prediction efficiency: The optimized code has fewer conditional branches, making it more CPU cache-friendly and reducing branch misprediction penalties.
• Memory access patterns: Dictionary lookups have better cache locality than repeated string comparisons across multiple if statements.

Performance Characteristics:
The optimization excels with larger parameter sets - showing 309% speedup in the test_large_scale_many_params case with 900+ parameters, where the original code's linear scanning becomes expensive. For small parameter sets (1-2 params), there's a slight overhead from dictionary creation, but this is negligible compared to the gains on realistic workloads with multiple OpenAI parameters being mapped.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 97 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 6 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from typing import Any, Optional

# imports
import pytest  # used for our unit tests
from litellm.llms.cohere.chat.transformation import CohereChatConfig

# unit tests

@pytest.fixture
def config():
    # Fixture to create a CohereChatConfig object
    return CohereChatConfig()

# 1. Basic Test Cases

def test_basic_single_param_mapping(config):
    # Test mapping a single OpenAI param
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.7},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.35μs -> 1.74μs (22.2% slower)

def test_basic_multiple_param_mapping(config):
    # Test mapping multiple OpenAI params
    params = {
        "temperature": 0.5,
        "max_tokens": 100,
        "n": 2,
        "top_p": 0.9,
        "frequency_penalty": 0.1,
        "presence_penalty": 0.2,
        "stop": ["END"],
        "tools": [{"name": "search"}],
        "seed": 42,
        "stream": True
    }
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 3.49μs -> 2.74μs (27.3% faster)

def test_basic_optional_params_preserved(config):
    # Test that existing optional_params are preserved and updated
    optional = {"foo": "bar", "temperature": 0.1}
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.9, "max_tokens": 50},
        optional_params=optional.copy(),
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.57μs -> 1.89μs (16.6% slower)

def test_basic_no_params(config):
    # Test when no params are provided
    codeflash_output = config.map_openai_params(
        non_default_params={},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 986ns -> 1.53μs (35.4% slower)

# 2. Edge Test Cases

def test_edge_unmapped_param_ignored(config):
    # Test that unmapped params are ignored
    codeflash_output = config.map_openai_params(
        non_default_params={"unknown_param": 123, "temperature": 0.4},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.48μs -> 1.68μs (11.7% slower)

def test_edge_max_completion_tokens_overrides_max_tokens(config):
    # Test that max_completion_tokens overrides max_tokens
    codeflash_output = config.map_openai_params(
        non_default_params={"max_tokens": 10, "max_completion_tokens": 20},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.48μs -> 1.79μs (17.6% slower)

def test_edge_stop_sequences_list_and_string(config):
    # Test stop_sequences mapping with both list and string
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": ["A", "B"]},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result_list = codeflash_output # 1.37μs -> 1.70μs (19.3% slower)
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": "C"},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result_str = codeflash_output # 680ns -> 829ns (18.0% slower)

def test_edge_tools_empty_list(config):
    # Test tools mapping with empty list
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": []},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.32μs -> 1.56μs (15.7% slower)

def test_edge_seed_zero_and_negative(config):
    # Test seed mapping with zero and negative values
    codeflash_output = config.map_openai_params(
        non_default_params={"seed": 0},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result_zero = codeflash_output # 1.27μs -> 1.49μs (15.0% slower)
    codeflash_output = config.map_openai_params(
        non_default_params={"seed": -123},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result_negative = codeflash_output # 598ns -> 782ns (23.5% slower)

def test_edge_param_overwrite(config):
    # Test that mapped param overwrites existing value in optional_params
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 1.0},
        optional_params={"temperature": 0.1},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.22μs -> 1.47μs (17.1% slower)

def test_edge_none_values_ignored(config):
    # Test that None values in non_default_params are ignored
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": None, "max_tokens": 50},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.47μs -> 1.62μs (9.56% slower)

def test_edge_empty_optional_params(config):
    # Test that function works with empty optional_params
    codeflash_output = config.map_openai_params(
        non_default_params={"frequency_penalty": 0.5},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.15μs -> 1.47μs (22.0% slower)

def test_edge_large_stop_sequences(config):
    # Test with a large list for stop_sequences
    stops = [str(i) for i in range(100)]
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": stops},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.27μs -> 1.57μs (19.2% slower)

def test_edge_large_tools(config):
    # Test with a large tools list
    tools = [{"name": f"tool_{i}"} for i in range(100)]
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": tools},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.29μs -> 1.62μs (20.2% slower)

# 3. Large Scale Test Cases

def test_large_scale_many_params(config):
    # Test mapping with many params (up to 1000)
    params = {f"param_{i}": i for i in range(900)}  # unmapped params
    # Add mapped params
    params.update({
        "temperature": 0.99,
        "max_tokens": 999,
        "n": 5,
        "top_p": 0.77,
        "frequency_penalty": 0.88,
        "presence_penalty": 0.66,
        "stop": ["END"],
        "tools": [{"name": "search"}],
        "seed": 123456,
        "stream": False
    })
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 112μs -> 27.6μs (309% faster)
    # Unmapped params should not be present
    for i in range(900):
        pass

def test_large_scale_large_stop_sequences(config):
    # Test with maximum allowed stop_sequences (1000 elements)
    stops = [str(i) for i in range(1000)]
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": stops},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.32μs -> 1.56μs (15.5% slower)

def test_large_scale_large_tools(config):
    # Test with maximum allowed tools (1000 elements)
    tools = [{"name": f"tool_{i}"} for i in range(1000)]
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": tools},
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.52μs -> 1.86μs (18.4% slower)

def test_large_scale_optional_params_prepopulated(config):
    # Test with large optional_params prepopulated
    optional = {f"foo_{i}": i for i in range(500)}
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.5},
        optional_params=optional.copy(),
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 1.35μs -> 1.62μs (16.4% slower)
    for i in range(500):
        pass

def test_large_scale_all_mapped_params(config):
    # Test with all mapped params set to large values
    params = {
        "temperature": 1.0,
        "max_tokens": 1000,
        "max_completion_tokens": 999,
        "n": 100,
        "top_p": 1.0,
        "frequency_penalty": 1.0,
        "presence_penalty": 1.0,
        "stop": ["A"] * 1000,
        "tools": [{"name": f"tool_{i}"} for i in range(1000)],
        "seed": 999999,
        "stream": True
    }
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="test-model",
        drop_params=False
    ); result = codeflash_output # 3.82μs -> 2.91μs (31.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from litellm.llms.cohere.chat.transformation import CohereChatConfig

# unit tests

# ---- BASIC TEST CASES ----

def test_map_basic_temperature():
    # Test that temperature is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.7},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.14μs -> 1.51μs (24.2% slower)

def test_map_basic_max_tokens():
    # Test that max_tokens is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"max_tokens": 123},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.08μs -> 1.47μs (26.4% slower)

def test_map_basic_max_completion_tokens():
    # Test that max_completion_tokens maps to max_tokens
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"max_completion_tokens": 456},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.11μs -> 1.43μs (22.4% slower)

def test_map_basic_n_to_num_generations():
    # Test that n is mapped to num_generations
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"n": 3},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.08μs -> 1.40μs (22.5% slower)

def test_map_basic_top_p_to_p():
    # Test that top_p is mapped to p
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"top_p": 0.8},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.21μs -> 1.52μs (20.5% slower)

def test_map_basic_frequency_penalty():
    # Test that frequency_penalty is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"frequency_penalty": 0.5},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.10μs -> 1.46μs (24.4% slower)

def test_map_basic_presence_penalty():
    # Test that presence_penalty is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"presence_penalty": 0.2},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.13μs -> 1.44μs (21.7% slower)

def test_map_basic_stop_sequences():
    # Test that stop is mapped to stop_sequences
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": ["\n", "END"]},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.17μs -> 1.47μs (20.7% slower)

def test_map_basic_tools():
    # Test that tools is mapped correctly
    config = CohereChatConfig()
    tools_val = [{"name": "search"}, {"name": "calculator"}]
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": tools_val},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.15μs -> 1.43μs (19.8% slower)

def test_map_basic_seed():
    # Test that seed is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"seed": 42},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.09μs -> 1.43μs (23.4% slower)

def test_map_basic_stream():
    # Test that stream is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"stream": True},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.05μs -> 1.34μs (21.9% slower)

def test_map_basic_multiple_params():
    # Test that multiple parameters are mapped correctly
    config = CohereChatConfig()
    params = {
        "temperature": 0.9,
        "max_tokens": 100,
        "top_p": 0.7,
        "n": 2,
        "stop": ["END"],
        "tools": [{"name": "search"}],
        "seed": 99
    }
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 2.63μs -> 2.20μs (19.8% faster)

def test_map_basic_optional_params_preserved():
    # Test that existing optional_params are preserved and updated
    config = CohereChatConfig()
    optional_params = {"existing": "value", "temperature": 0.1}
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.5},
        optional_params=optional_params.copy(),
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.06μs -> 1.41μs (24.9% slower)

# ---- EDGE TEST CASES ----

def test_map_edge_empty_non_default_params():
    # Test with empty non_default_params
    config = CohereChatConfig()
    optional_params = {"existing": "value"}
    codeflash_output = config.map_openai_params(
        non_default_params={},
        optional_params=optional_params.copy(),
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 780ns -> 1.25μs (37.7% slower)

def test_map_edge_none_values():
    # Test with None values in non_default_params (should still set them)
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": None, "max_tokens": None},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.33μs -> 1.62μs (17.9% slower)

def test_map_edge_unmapped_param():
    # Test with a parameter that is not mapped (should not appear in result)
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"unknown_param": "value"},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 958ns -> 1.30μs (26.3% slower)

def test_map_edge_conflicting_max_tokens():
    # If both max_tokens and max_completion_tokens are set, last one wins
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"max_tokens": 50, "max_completion_tokens": 60},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.38μs -> 1.60μs (14.0% slower)

def test_map_edge_stop_sequences_type():
    # stop can be string or list; ensure both are mapped
    config = CohereChatConfig()
    # As string
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": "\n"},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result1 = codeflash_output # 1.09μs -> 1.47μs (25.6% slower)
    # As list
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": ["\n", "END"]},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result2 = codeflash_output # 621ns -> 833ns (25.5% slower)

def test_map_edge_tools_empty_list():
    # Test that empty tools list is mapped correctly
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": []},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.09μs -> 1.38μs (21.0% slower)

def test_map_edge_seed_zero():
    # Test that seed=0 is mapped correctly (since 0 is a valid seed)
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"seed": 0},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.14μs -> 1.34μs (15.6% slower)

def test_map_edge_boolean_values():
    # Test boolean values for stream and search_queries_only
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"stream": False, "search_queries_only": True},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.21μs -> 1.42μs (15.0% slower)

def test_map_edge_parameter_order():
    # Test that mapping order is correct (last param wins)
    config = CohereChatConfig()
    codeflash_output = config.map_openai_params(
        non_default_params={"max_tokens": 10, "max_completion_tokens": 20, "max_tokens": 30},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.39μs -> 1.54μs (9.98% slower)

def test_map_edge_optional_params_mutation():
    # Ensure that optional_params is mutated in place
    config = CohereChatConfig()
    optional_params = {}
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 0.1},
        optional_params=optional_params,
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.05μs -> 1.36μs (22.7% slower)

# ---- LARGE SCALE TEST CASES ----

def test_map_large_many_params():
    # Test mapping with many parameters
    config = CohereChatConfig()
    # Generate 100 distinct parameters, only some are mapped
    params = {f"param{i}": i for i in range(100)}
    # Add all supported mapped params with unique values
    mapped_params = {
        "temperature": 0.99,
        "max_tokens": 999,
        "max_completion_tokens": 888,
        "n": 77,
        "top_p": 0.77,
        "frequency_penalty": 0.11,
        "presence_penalty": 0.22,
        "stop": ["END"],
        "tools": [{"name": "tool"}],
        "seed": 123,
        "stream": True
    }
    params.update(mapped_params)
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 16.0μs -> 5.73μs (179% faster)
    # Unmapped params should not be present
    for i in range(100):
        pass

def test_map_large_optional_params():
    # Test with large optional_params dict
    config = CohereChatConfig()
    optional_params = {f"existing{i}": f"value{i}" for i in range(500)}
    codeflash_output = config.map_openai_params(
        non_default_params={"temperature": 1.0, "n": 2},
        optional_params=optional_params.copy(),
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.49μs -> 1.73μs (13.6% slower)
    # Should preserve all existing keys
    for i in range(500):
        pass

def test_map_large_stop_sequences():
    # Test with large stop_sequences list
    config = CohereChatConfig()
    stop_list = [str(i) for i in range(500)]
    codeflash_output = config.map_openai_params(
        non_default_params={"stop": stop_list},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.24μs -> 1.50μs (17.2% slower)

def test_map_large_tools_list():
    # Test with large tools list
    config = CohereChatConfig()
    tools_list = [{"name": f"tool{i}"} for i in range(500)]
    codeflash_output = config.map_openai_params(
        non_default_params={"tools": tools_list},
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 1.29μs -> 1.50μs (13.6% slower)

def test_map_large_all_supported_params():
    # Test with all supported params set at once
    config = CohereChatConfig()
    params = {
        "stream": False,
        "temperature": 0.5,
        "max_tokens": 100,
        "max_completion_tokens": 200,
        "n": 5,
        "top_p": 0.3,
        "frequency_penalty": 0.1,
        "presence_penalty": 0.2,
        "stop": ["A", "B", "C"],
        "tools": [{"name": "search"}, {"name": "calc"}],
        "seed": 12345
    }
    codeflash_output = config.map_openai_params(
        non_default_params=params,
        optional_params={},
        model="any-model",
        drop_params=False
    ); result = codeflash_output # 3.41μs -> 2.59μs (31.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from litellm.llms.cohere.chat.transformation import CohereChatConfig
from litellm.proxy._types import UserManagementEndpointParamDocStringEnums

def test_CohereChatConfig_map_openai_params():
    CohereChatConfig.map_openai_params(CohereChatConfig(preamble='', chat_history=[], generation_id=None, response_id='', conversation_id='', prompt_truncation='', connectors=[], search_queries_only=False, documents=None, temperature=0, max_tokens=None, max_completion_tokens=0, k=None, p=0, frequency_penalty=None, presence_penalty=None, tools=None, tool_results=[], seed=None), {'stream': 0}, {}, '', False)

def test_CohereChatConfig_map_openai_params_2():
    CohereChatConfig.map_openai_params(CohereChatConfig(preamble=None, chat_history=None, generation_id=None, response_id='', conversation_id=None, prompt_truncation=None, connectors=[], search_queries_only=False, documents=[], temperature=None, max_tokens=None, max_completion_tokens=None, k=None, p=None, frequency_penalty=None, presence_penalty=0, tools=None, tool_results=[], seed=0), {'temperature': 0}, {'temperature': 0}, '', False)

def test_CohereChatConfig_map_openai_params_3():
    CohereChatConfig.map_openai_params(CohereChatConfig(preamble=None, chat_history=None, generation_id=None, response_id='', conversation_id=None, prompt_truncation=None, connectors=[], search_queries_only=None, documents=None, temperature=None, max_tokens=None, max_completion_tokens=0, k=None, p=None, frequency_penalty=None, presence_penalty=0, tools=[], tool_results=[], seed=None), {'\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00': '', 'top_p': '', '\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00': 0, UserManagementEndpointParamDocStringEnums.user_alias_doc_str: ''}, {}, '', False)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_zbim32de/tmps77pjql0/test_concolic_coverage.py::test_CohereChatConfig_map_openai_params	928ns	1.29μs	-28.0%⚠️
codeflash_concolic_zbim32de/tmps77pjql0/test_concolic_coverage.py::test_CohereChatConfig_map_openai_params_2	907ns	1.26μs	-28.1%⚠️
codeflash_concolic_zbim32de/tmps77pjql0/test_concolic_coverage.py::test_CohereChatConfig_map_openai_params_3	1.45μs	1.52μs	-4.92%⚠️

To edit these changes git checkout codeflash/optimize-CohereChatConfig.map_openai_params-mhdo8ovm and push.