fix: add custom_body parameter to endpoint_func in create_pass_through_route

[themavik]

Summary

Fixes #16999

The bedrock_proxy_route calls endpoint_func(custom_body=data) to pass a pre-parsed, SigV4-signed request body to the pass-through handler. However, the endpoint_func closure created by create_pass_through_route does not accept a custom_body keyword argument, causing:

TypeError: create_pass_through_route.<locals>.endpoint_func() got an unexpected keyword argument 'custom_body'

This crashes all Bedrock knowledge base retrieve requests going through the v1 passthrough.

Root Cause

create_pass_through_route defines two variants of endpoint_func:

1. Adapter-based (when target is a CustomLogger)
2. URL-based (when target is a URL string)

Neither accepts custom_body as a parameter. The bedrock proxy route at line 1050 passes custom_body=data as a keyword argument, which fails.

Fix

• Add custom_body: Optional[dict] = None to both endpoint_func signatures.
• In the URL-based path, when custom_body is provided by the caller, use it directly instead of re-parsing the body from the raw request. This is the correct behavior since the bedrock proxy has already parsed and signed the body.

Changes

• litellm/proxy/pass_through_endpoints/pass_through_endpoints.py

Test Plan

• Verify Bedrock knowledge base retrieve requests through the proxy no longer crash with TypeError.
• Verify other pass-through endpoints (Vertex, Azure, etc.) are unaffected since they don't pass custom_body.
• Verify that the URL-based endpoint still correctly parses the body from the request when custom_body is not provided.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
litellm	Ready	Preview, Comment	Feb 11, 2026 7:33am

[greptile-apps]

Greptile Overview

Greptile Summary

This PR fixes a runtime TypeError in the v1 Bedrock passthrough by updating the endpoint_func closures created by create_pass_through_route to accept a custom_body kwarg. In the URL-based passthrough path, it also prefers a caller-supplied body (e.g., Bedrock’s pre-parsed, SigV4-signed JSON) over the request-parsed body before calling pass_through_request.

The change fits into the proxy passthrough architecture by allowing higher-level routes (like bedrock_proxy_route) to inject a prepared body into the generic passthrough handler without re-parsing/mutating it inside create_pass_through_route.

Confidence Score: 4/5

• Mostly safe to merge, but there is one behavioral inconsistency around the new custom_body parameter in the adapter-based passthrough path.
• The URL-based passthrough fix addresses the reported crash and correctly allows Bedrock to supply a pre-parsed body. However, the adapter-based endpoint_func signature now accepts custom_body but does not use/forward it, which can lead to silent incorrect behavior for any callers relying on custom bodies when the adapter branch is selected.
• litellm/proxy/pass_through_endpoints/pass_through_endpoints.py

Important Files Changed

Filename	Overview
litellm/proxy/pass_through_endpoints/pass_through_endpoints.py	Adds custom_body kwarg to create_pass_through_route endpoint closures and prefers the provided body over parsed request body in the URL-based passthrough path; adapter-based path currently ignores the new parameter.

Sequence Diagram

sequenceDiagram
    participant Client
    participant Proxy as Proxy(FastAPI)
    participant Bedrock as bedrock_proxy_route
    participant Factory as create_pass_through_route
    participant Parse as _parse_request_data_by_content_type
    participant PT as pass_through_request
    participant Target as External Target URL

    Client->>Proxy: "POST /bedrock/{endpoint}"
    Proxy->>Bedrock: "bedrock_proxy_route(request)"
    Bedrock->>Bedrock: "parse JSON body"
    Bedrock->>Bedrock: "SigV4 sign headers/url"
    Bedrock->>Factory: "create_pass_through_route(target=prepped.url, headers=prepped.headers)"
    Factory-->>Bedrock: "endpoint_func"
    Bedrock->>Factory: "endpoint_func(custom_body=data)"

    alt "URL-based target"
        Factory->>Parse: "parse query/body from raw request"
        Factory->>Factory: "if custom_body != None use it"
        Factory->>PT: "pass_through_request(custom_body=final_custom_body)"
        PT->>Target: "HTTP request"
        Target-->>PT: "response"
        PT-->>Bedrock: "response"
    else "Adapter-based target"
        Factory->>Proxy: "chat_completion_pass_through_endpoint(...)"
        Note over Factory,Proxy: "custom_body currently not forwarded"
        Proxy-->>Bedrock: "response"
    end

    Bedrock-->>Client: "response"

Loading

[greptile-apps]

_{1 file reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

Additional Comments (1)

litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
Unused custom_body param

In the adapter-based branch, endpoint_func now accepts custom_body but never forwards it, so callers that pass custom_body (like bedrock_proxy_route) will still have their custom body ignored whenever target resolves to an adapter (i.e., get_instance_fn(value=target) succeeds). If the intent is to support custom_body uniformly, it should be passed through to chat_completion_pass_through_endpoint (or removed from this signature if adapters can’t support it).

[jquinter]

Review Feedback

Thanks for the fix — this addresses a real TypeError crash on Bedrock knowledge base retrieve requests via v1 passthrough.

Greptile's finding is correct: adapter-based path silently ignores custom_body

As @greptile-apps flagged, the adapter-based endpoint_func (line ~1097) now accepts custom_body but never forwards it to chat_completion_pass_through_endpoint:

async def endpoint_func(
    request: Request,
    fastapi_response: Response,
    user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),
    subpath: str = "",
    custom_body: Optional[dict] = None,  # ← accepted but never used
):
    return await chat_completion_pass_through_endpoint(
        fastapi_response=fastapi_response,
        request=request,
        adapter_id=adapter_id,
        user_api_key_dict=user_api_key_dict,
        # custom_body not forwarded
    )

This means the TypeError is fixed (no crash), but if a caller passes custom_body and the target resolves to an adapter, the body is silently dropped. In practice Bedrock targets resolve to URLs not adapters, so this is unlikely to trigger today — but it's a latent issue.

Suggestion: At minimum add a comment in the adapter path explaining why custom_body is intentionally not forwarded. Ideally, forward it if the downstream function supports it.

No tests

The PR doesn't include any tests. Even a basic test verifying endpoint_func can be called with custom_body=some_dict without TypeError would add confidence and prevent regressions.

URL-based path fix looks correct

The precedence logic (caller-supplied body > request-parsed body) is the right approach and the implementation is clean.

[greptile-apps]

You're right — chat_completion_pass_through_endpoint doesn't currently accept a custom_body parameter, so forwarding it would cause another TypeError.

Current state:

• The adapter-based path accepts custom_body but silently ignores it
• This prevents crashes but creates a latent bug
• If Bedrock (or any caller) passes custom_body to an adapter target, the pre-parsed body is silently dropped and the request will re-parse from request.body()

Options:

1. Document the limitation (minimal fix):
   Add a comment explaining custom_body is accepted for signature compatibility but ignored because chat_completion_pass_through_endpoint doesn't support it.

2. Forward it (if supported downstream):
   If chat_completion_pass_through_endpoint can be extended to accept custom_body, forward it. This would require checking if the adapter flow can use pre-parsed bodies.

3. Raise an error (strictest):
   If custom_body is not None in the adapter path, raise an error explaining that custom bodies aren't supported for adapter targets.

Since Bedrock targets currently resolve to URLs (not adapters), option 1 is the safest short-term fix. But if there's any chance adapter targets will need custom_body in the future, option 2 is more future-proof.

[krrishdholakia]

@themavik can you please make the requested changes?

@shin-bot-litellm for monitoring

[themavik]

Addressed the review feedback:

1. Adapter-based path comment — Added an inline comment on the custom_body parameter in the adapter-based endpoint_func explaining it is accepted for signature compatibility with the URL-based path but not forwarded, since chat_completion_pass_through_endpoint does not support it.

2. Tests — Added two mocked tests in tests/test_litellm/proxy/pass_through_endpoints/test_pass_through_endpoints.py:

   • test_create_pass_through_route_custom_body_url_target: Verifies that when a caller (e.g. bedrock_proxy_route) supplies custom_body, it takes precedence over the body parsed from the raw request.
   • test_create_pass_through_route_no_custom_body_falls_back: Verifies that when custom_body is not provided, the existing behavior (use request-parsed body) is preserved.

   Both tests follow the project's mocked-test conventions from CONTRIBUTING.md and match the patterns already in the test file (e.g. test_create_pass_through_route_with_cost_per_request).

[jquinter]

@greptile-apps review this PR please

[greptile-apps]

Greptile Overview

Greptile Summary

Fixes a TypeError crash when Bedrock knowledge base retrieve requests are made through the v1 pass-through proxy. The bedrock_proxy_route passes custom_body=data to endpoint_func, but neither closure variant in create_pass_through_route accepted this keyword argument.

• Added custom_body: Optional[dict] = None to both the adapter-based and URL-based endpoint_func signatures
• In the URL-based path, when custom_body is provided by the caller, it is used directly instead of re-parsing the body from the raw request
• The adapter-based path accepts but does not forward custom_body, since chat_completion_pass_through_endpoint does not support it
• Two mock-only tests added to verify the fix and the fallback behavior

Confidence Score: 4/5

• This PR is safe to merge — it's a targeted bug fix with minimal blast radius and good test coverage.
• The fix is narrowly scoped to add a missing parameter and plumb it through correctly. The custom_body parameter defaults to None, so all existing callers (Vertex, Cohere, Anthropic, etc.) that don't pass it are unaffected. The two new tests are mock-based and verify both the fix and the fallback path. The only reason it's not a 5 is the adapter-based path silently ignores the parameter rather than forwarding it.
• No files require special attention.

Important Files Changed

Filename	Overview
litellm/proxy/pass_through_endpoints/pass_through_endpoints.py	Added custom_body parameter to both adapter-based and URL-based endpoint_func closures, and updated body selection logic to prefer caller-supplied body over request-parsed body. Fixes TypeError crash on Bedrock knowledge base retrieve requests.
tests/test_litellm/proxy/pass_through_endpoints/test_pass_through_endpoints.py	Added two mock-only tests: one verifying custom_body is forwarded and takes precedence over the parsed request body, and one verifying fallback to parsed body when custom_body is not provided.

[greptile-apps]

_{2 files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}