ConfigMap model blocks: GPT-5 entries updated correctly.

Change is consistent with other environments.

Add a one-liner comment above the GPT-5 blocks to indicate reasoning_effort is GPT-5–specific.

Also applies to: 91-91, 98-98

🏁 Script executed:

#!/bin/bash
# Sanity check: reason param presence only on GPT-5 blocks inside this CM
rg -n 'gpt-5' -n -A10 deployment/kustomizations/base/cm.yaml | rg -n 'reasoning_effort'
rg -n 'gpt-4\.1' -n -A10 deployment/kustomizations/base/cm.yaml | rg -n 'reasoning_effort' || echo "No gpt-4.1 blocks with reasoning_effort found."

Length of output: 398

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Whitelist reasoning_effort carefully; confirm litellm allowlist semantics and router timeout.

• Good gating of reasoning_effort to GPT-5. To reduce risk, pass allowed_openai_params only when the key is actually present in generation_kwargs (and for GPT-5). Also, consider passing timeout to the router call for parity with direct calls (if supported).

-            allowed_params = (
-                ["reasoning_effort"] if self._model.startswith("gpt-5") else None
-            )
+            has_reasoning = "reasoning_effort" in generation_kwargs
+            allowed_params = (
+                ["reasoning_effort"]
+                if self._model.startswith("gpt-5") and has_reasoning
+                else None
+            )
@@
-                completion = await self._router.acompletion(
+                completion = await self._router.acompletion(
                     model=self._model,
                     messages=openai_formatted_messages,
                     stream=streaming_callback is not None,
                     allowed_openai_params=allowed_params,
+                    # align with direct call if supported by litellm Router
+                    # timeout=self._timeout,
                     mock_testing_fallbacks=self._enable_fallback_testing,
                     **generation_kwargs,
                 )

Please confirm two points to ensure we won’t drop other kwargs inadvertently:

And check whether the router supports a timeout kwarg:

Additionally, confirm the repository’s litellm version to decide on import compatibility and supported kwargs:

Also applies to: 112-112, 125-125

🏁 Script executed:

#!/bin/bash
# Find litellm version constraints
rg -n 'litellm' -g '!node_modules' -S
fd -a 'requirements*.txt|pyproject.toml|poetry.lock|Pipfile*' | xargs -I{} rg -n --no-heading 'litellm' {}

Length of output: 65656

🌐 Web query:

In litellm, what is the exact behavior of the `allowed_openai_params` argument for acompletion/router? Does it strictly allowlist only those keys or augment the default set of supported OpenAI params?

💡 Result:

In LiteLLM, the allowed_openai_params argument for a completion or router function specifies which OpenAI parameters are permitted in the request. By default, LiteLLM restricts the use of certain OpenAI parameters to ensure compatibility with the selected model and provider. If you encounter a litellm.UnsupportedParamsError due to the inclusion of a parameter not supported by the current model or provider, you can use allowed_openai_params to explicitly allow that parameter. This approach does not augment the default set of supported OpenAI parameters; instead, it serves as an allowlist, permitting specific parameters that would otherwise be restricted.

For example, if you need to use the tools parameter with a model that doesn't support it by default, you can include it in the allowed_openai_params list:

await litellm.acompletion(
    model="azure/o_series/<my-deployment-name>",
    api_key="xxxxx",
    api_base=api_base,
    messages=[{"role": "user", "content": "Hello! return a json object"}],
    tools=[{"type": "function", "function": {"name": "get_current_time", "description": "Get the current time in a given location.", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The city name, e.g. San Francisco"}}, "required": ["location"]}}}],
    allowed_openai_params=["tools"],
)

In this example, specifying allowed_openai_params=["tools"] tells LiteLLM to permit the tools parameter in the request, even if it's not part of the default supported parameters for the chosen model and provider. (docs.litellm.ai)

Therefore, the allowed_openai_params argument functions as an explicit allowlist, enabling the use of specific OpenAI parameters that are not included in the default set of supported parameters for the selected model and provider.

Citations:

• 1: https://docs.litellm.ai/docs/completion/drop_params?utm_source=openai

🌐 Web query:

Does litellm Router.acompletion accept a `timeout` parameter similar to `litellm.acompletion`?

💡 Result:

Yes, the Router.acompletion method in LiteLLM accepts a timeout parameter, similar to litellm.acompletion. This parameter allows you to specify the maximum duration (in seconds) that the completion request should wait for a response before timing out.

You can set the timeout parameter in two ways:

1. Global Timeout for All Calls: When initializing the Router, you can set a global timeout that applies to all completion requests made through that router instance.

   from litellm import Router
   
   model_list = [{...}]
   router = Router(model_list=model_list, timeout=30)  # Timeout set to 30 seconds

   In this example, any completion request made through router will have a timeout of 30 seconds. (docs.litellm.ai)

2. Timeout for Individual Models: You can specify a timeout for each model by including the timeout parameter within the litellm_params for that model.

   from litellm import Router
   import asyncio
   
   model_list = [{
       "model_name": "gpt-3.5-turbo",
       "litellm_params": {
           "model": "azure/chatgpt-v-2",
           "api_key": os.getenv("AZURE_API_KEY"),
           "api_version": os.getenv("AZURE_API_VERSION"),
           "api_base": os.getenv("AZURE_API_BASE"),
           "timeout": 300  # Timeout set to 300 seconds (5 minutes)
       }
   }]
   
   router = Router(model_list=model_list, routing_strategy="least-busy")
   
   async def router_acompletion():
       response = await router.acompletion(
           model="gpt-3.5-turbo",
           messages=[{"role": "user", "content": "Hey, how's it going?"}]
       )
       print(response)
       return response
   
   asyncio.run(router_acompletion())

   In this setup, the gpt-3.5-turbo model has a timeout of 300 seconds (5 minutes). (docs.litellm.ai)

By configuring the timeout parameter, you can control how long the system waits for a response before considering the request as failed due to a timeout.

Citations:

• 1: https://docs.litellm.ai/docs/proxy/timeout?utm_source=openai
• 2: https://docs.litellm.ai/docs/proxy/timeout?utm_source=openai

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Reasoning effort for GPT-5: looks good; verify accepted values and scope.

• LGTM adding reasoning_effort: minimal only to GPT-5 variants; 4.1 models remain unchanged.
• Please confirm the accepted enum for this field (e.g., minimal/medium/maximal) and that litellm forwards it only for GPT-5 as intended.

Consider adding an inline comment documenting allowed values and that this is GPT-5–specific.

Run to double-check repository-wide consistency:

Also applies to: 40-40, 47-47

🏁 Script executed:

#!/bin/bash
# 1) Ensure we don't set reasoning_effort for non-GPT-5 models
rg -n 'reasoning_effort' -A2 -B4

# 2) Verify all GPT-5 model blocks carry the field
rg -n $'model: gpt-5' -A10 | rg -n 'reasoning_effort' -n

Length of output: 7067

Full config updated correctly for GPT-5; verify no leakage to other models.

Looks correct and consistent with other config files.

Add a short comment near the first GPT-5 model block noting this param is GPT-5–specific.

Also applies to: 40-40, 47-47

🏁 Script executed:

#!/bin/bash
# Assert no gpt-4.* blocks contain reasoning_effort
rg -n 'model:\s*gpt-4' -A8 | rg -n 'reasoning_effort' || echo "No gpt-4 blocks with reasoning_effort found."

Length of output: 152