fix(responses): forward timeout on completion transformation path (Anthropic, Bedrock, Vertex)

[cwang-otto]

What this fixes

litellm.responses() / litellm.aresponses() silently drops the timeout parameter on the completion transformation path (used by Anthropic, Vertex AI Claude, Bedrock, and any provider without a native BaseResponsesAPIConfig). The timeout works correctly on the native Responses API path (OpenAI, Azure).

Net effect: Router(timeout=N) is a no-op for Anthropic models — calls fall back to the Anthropic SDK default (~600s).

Filed as #28132.

Root cause

timeout is declared as a named parameter of responses() — so it's removed from **kwargs by Python. The completion transformation path passed **kwargs to its handler, silently dropping the consumed value:

# litellm/responses/main.py — completion transformation path (buggy)
if responses_api_provider_config is None or use_chat_completions_api is True:
    return litellm_completion_transformation_handler.response_api_handler(
        ...
        extra_body=extra_body,
        **kwargs,    # <-- timeout was consumed as a named param, NOT in kwargs
    )

The native path already forwards it explicitly (timeout=timeout or request_timeout on line 1169). This PR mirrors that pattern.

Same class of bug as #22544, which fixed metadata silently dropping on the same path.

The fix

One line in litellm/responses/main.py:

if responses_api_provider_config is None or use_chat_completions_api is True:
    return litellm_completion_transformation_handler.response_api_handler(
        ...
        extra_body=extra_body,
        timeout=timeout or request_timeout,   # <-- added
        **kwargs,
    )

The downstream handler already accepts **kwargs and forwards them to litellm.completion() / litellm.acompletion(), which respects timeout natively.

Verification

1. Unit test (added in tests/llm_responses_api_testing/test_anthropic_responses_api.py)

test_aresponses_forwards_timeout_to_acompletion mocks litellm.acompletion and asserts that timeout=42 passed to litellm.aresponses() reaches the underlying acompletion call.

Verified red→green:

• Without the fix: AssertionError: timeout was not forwarded to acompletion (got None)
• With the fix: PASSED

2. End-to-end repro with a slow HTTP server

A standalone repro spins up a local HTTP server that accepts the connection then sleeps 30s before responding. We call litellm.aresponses(model="anthropic/...", timeout=3) pointed at it.

Scenario	Without fix	With fix
Anthropic non-streaming	hung 30.0s	timeout fired at 3.1s
Anthropic streaming	hung 30.1s	timeout fired at 3.0s

Repro script (uses no real API key — api_base is overridden to local slow server):

Click to expand

import asyncio
import time
import litellm

SLOW_PORT = 18299
SLOW_DELAY = 30
TIMEOUT = 3

_FAKE_RESPONSE = b'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{"id":"msg_fake","type":"message","role":"assistant","content":[{"type":"text","text":"ok"}],"model":"claude-sonnet-4-6","stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}'

async def _handle(reader, writer):
    try:
        while True:
            line = await asyncio.wait_for(reader.readline(), timeout=5)
            if line in (b"\r\n", b"", b"\n"):
                break
        await asyncio.sleep(SLOW_DELAY)
        writer.write(_FAKE_RESPONSE)
        await writer.drain()
    finally:
        writer.close()
        try: await writer.wait_closed()
        except: pass

async def main():
    server = await asyncio.start_server(_handle, "127.0.0.1", SLOW_PORT)
    try:
        for label, stream in [("non-streaming", False), ("streaming", True)]:
            t0 = time.monotonic()
            try:
                resp = await litellm.aresponses(
                    model="anthropic/claude-sonnet-4-6",
                    input=[{"role": "user", "content": "hi"}],
                    api_base=f"http://127.0.0.1:{SLOW_PORT}",
                    api_key="sk-ant-fake",
                    timeout=TIMEOUT,
                    stream=stream,
                    num_retries=0,
                )
                if stream and hasattr(resp, "__aiter__"):
                    async for _ in resp: pass
                print(f"{label}: HUNG {time.monotonic()-t0:.1f}s — timeout dropped")
            except Exception as e:
                print(f"{label}: timed out at {time.monotonic()-t0:.1f}s — {type(e).__name__}")
    finally:
        server.close()
        await server.wait_closed()

asyncio.run(main())

Other named params at risk (same class)

While this PR targets timeout, the same wrong-pattern affects other parameters declared as named in responses() but not in response_api_optional_params. Easy follow-up — extra_query is the most notable.

Parameter	Completion path	Native path
timeout	dropped (this PR)	forwarded
extra_query	dropped	forwarded
metadata	fixed in #22544	forwarded

Affected providers

Any provider routed via completion transformation (i.e. no native BaseResponsesAPIConfig):

• Anthropic (anthropic/claude-*)
• Vertex AI (vertex_ai/claude-*)
• Bedrock (bedrock/anthropic.*)
• Any other provider lacking native Responses API support

Related

• Issue responses(): timeout parameter silently dropped on completion transformation path (Anthropic, Bedrock, Vertex) #28132 — full bug report
• PR fix(responses): forward metadata to Langfuse/callbacks on completion transformation path #22544 — metadata fix (same bug class, same fix shape)
• PR [Fix] Request Timeout needs to be also fetched from litellm_settings.request_timeout #25591 — separate timeout fix path (litellm_settings-derived timeouts)

[greptile-apps]

Greptile Summary

This PR fixes timeout being silently dropped on the completion transformation path of litellm.responses() / litellm.aresponses(), which caused Router(timeout=N) to be a no-op for Anthropic, Vertex AI Claude, and Bedrock providers.

• litellm/responses/main.py: Adds timeout=timeout or request_timeout to the response_api_handler call, mirroring the identical pattern already used on every other handler path in the file.
• litellm/responses/litellm_completion_transformation/handler.py: Removes 4 lines of dead code — a completion_args dict that was built via two .update() calls but never actually passed to litellm.completion() (the call site already used **litellm_completion_request, **kwargs directly).
• Test: Adds a mock-only regression test in the existing Anthropic test file verifying that timeout=42 propagates from aresponses() all the way to acompletion().

Confidence Score: 5/5

This PR is safe to merge — it adds a single missing keyword argument to one call site and cleans up dead code that was never executed.

The change is minimal and targeted: one new argument forwarded on the completion transformation path, matching the identical pattern used on every other path in the same function. The dead-code removal in the handler has no runtime effect. The new mock test provides direct regression coverage without touching existing assertions.

No files require special attention.

Important Files Changed

Filename	Overview
litellm/responses/main.py	Adds timeout=timeout or request_timeout to the completion transformation path call, mirroring the identical pattern already used on all other handler paths in this file.
litellm/responses/litellm_completion_transformation/handler.py	Removes 4 lines of dead code (completion_args dict that was built but never passed to litellm.completion); the call site already used **litellm_completion_request, **kwargs directly.
tests/llm_responses_api_testing/test_anthropic_responses_api.py	Adds a mock-only regression test asserting timeout is forwarded through aresponses() to acompletion() on the completion transformation path; no real network calls.

_{Reviews (2): Last reviewed commit: "chore(responses): remove unused completi..." | Re-trigger Greptile}

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[oss-pr-review-agent-shin]

🤖 litellm-agent: This PR is currently BLOCKED from merge.

Score: 4/5 ❌

Why blocked:

• 1 unresolved reviewer concern (greptile) (unresolved_concern, -1 pts)

Details: Score docked for: 1 unresolved reviewer concern (greptile).

Fix the issues above and push an update — the bot will re-review automatically.

Note: This bot is still in beta and might not always work as expected. Please share any feedback via Slack.

[cwang-otto]

@greptileai

[oss-pr-review-agent-shin]

🤖 litellm-agent: Squash-merged into staging branch shin_agent_oss_staging_05_18_2026. Staging PR: #28144

---

Triage Summary
Fixes a silent timeout drop on the completion transformation path of litellm.responses() and litellm.aresponses(). The timeout parameter was consumed as a named argument but never forwarded to the underlying response_api_handler call, making Router(timeout=N) a no-op for Anthropic, Vertex AI Claude, and Bedrock providers. The fix adds timeout=timeout or request_timeout to that call site, mirroring the identical pattern already used on the native Responses API path. Also removes four lines of dead code in handler.py (a completion_args dict that was built but never passed anywhere) and adds a…

Merge Confidence: 5/5 ✅ READY
Ready to ship.

All checks green. Greptile 5/5, no blocking pattern findings, no CircleCI runs (OSS-typical).