tensorrt_llm/_torch/pyexecutor/py_executor.py (1)

1158-1160:Fix broken _handle_errors call in _fetch_and_activate_new_requests

_handle_errors no longer accepts the requests= kwarg — that call will raise TypeError at runtime. Replace it to pass request_ids (the codebase uses request.request_id elsewhere).

• File: tensorrt_llm/_torch/pyexecutor/py_executor.py — around line 1159

Apply:

-            except Exception as e:-                self._handle_errors(str(e), requests=[request])+            except Exception as e:+                self._handle_errors(str(e), request_ids=[request.request_id])                 return True

cpp/tensorrt_llm/batch_manager/dataTransceiver.h (1)

154-162:Consistency: consider using NEW_TLLM_REQUEST_SPECIFIC_EXCEPTION_WITH_ERROR_CODE macro

For consistency with the rest of the codebase and to auto-capture file/line, prefer the macro wrapper over directly invoking the constructor. It also standardizes message formatting.

Also applies to: 167-175

cpp/tensorrt_llm/executor/cache_transmission/ucx_utils/connection.cpp (1)

23-23:Remove unused include and aliases

tllmException.h and the RequestSpecificException/RequestErrorCode aliases are not used in this TU. Trim them to reduce compile overhead and avoid symbol pollution within the namespace.

Apply this diff:

-#include "tensorrt_llm/common/tllmException.h"@@-// Using declarations to shorten the code-using RequestSpecificException = tensorrt_llm::common::RequestSpecificException;-using RequestErrorCode = tensorrt_llm::common::RequestErrorCode;

Also applies to: 29-32

cpp/tensorrt_llm/pybind/common/tllmExceptions.h (2)

2-2:Update copyright year

Per coding guidelines, use the current year. Suggest updating 2022-2024 to 2025.

Apply this diff:

- * Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.+ * Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.

---

22-24:Remove unused namespace alias

The tc alias is unused in this header and leaks a global alias into every including TU. Drop it.

Apply this diff:

-namespace py = pybind11;-namespace tc = tensorrt_llm::common;+namespace py = pybind11;

tests/unittest/others/test_exception.py (3)

1-3:Add NVIDIA copyright header (current year)

All Python sources should include the NVIDIA header.

Apply this diff:

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.+# SPDX-License-Identifier: Apache-2.0+ import sys-from tensorrt_llm.bindings.exceptions import RequestSpecificException+from tensorrt_llm.bindings.exceptions import RequestSpecificException

---

16-23:Fix unreachable except block by ordering specific before base

Catching Exception first makes the RequestSpecificException except unreachable. Reverse the order to test both semantics.

Apply this diff:

 def test_exception_inheritance():     """Test that exception properly inherits from base Exception."""     try:         raise RequestSpecificException("Test inheritance")-    except Exception as e:  # Should catch base Exception-        assert isinstance(e, RequestSpecificException)-    except RequestSpecificException as e:  # Should also catch specific type-        assert isinstance(e, RequestSpecificException)+    except RequestSpecificException as e:  # Catch specific type+        assert isinstance(e, RequestSpecificException)+    except Exception as e:  # And also as base Exception+        assert isinstance(e, Exception)

---

25-33:Optionally assert default attributes more strongly

If the binding sets defaults, consider asserting request_id and error_code are present and not None. Import RequestErrorCode if you plan to validate its type/value explicitly.

Apply this diff:

-from tensorrt_llm.bindings.exceptions import RequestSpecificException+from tensorrt_llm.bindings.exceptions import RequestSpecificException, RequestErrorCode@@     except RequestSpecificException as e:         # Check that attributes exist (they might be None if not set by C++)         assert hasattr(e, 'request_id'), "request_id attribute missing"         assert hasattr(e, 'error_code'), "error_code attribute missing"+        # Optional stronger checks if translator sets defaults+        # assert e.error_code in (None, RequestErrorCode.UNKNOWN_ERROR)

cpp/tensorrt_llm/common/tllmException.cpp (1)

1-3:Update copyright year.

Guidelines require current year. Please update 2022-2024 to 2022-2025.

cpp/tensorrt_llm/batch_manager/dataTransceiver.cpp (1)

194-200:Consider releasing the session on failure to avoid leaks/stale state.

On exception,mSender->release(id) is not called. Verify whether release is required even on failure to prevent resource leaks or dangling counterpart state.

If release is safe in failure paths, add it guarded with try/catch:

         catch (tensorrt_llm::common::RequestSpecificException const& e)         {             TLLM_LOG_ERROR("Exception in sendAndRemoveResponse: %s ", e.what());             auto new_exception                 = NEW_TLLM_REQUEST_SPECIFIC_EXCEPTION_WITH_ERROR_CODE(id, e.getErrorCode(), "%s", e.what());             resp.mPromise.set_exception(std::make_exception_ptr(new_exception));+            try {+                mSender->release(id);+            } catch (std::exception const& ex) {+                TLLM_LOG_WARNING("Release after failure also failed for request %zu: %s", static_cast<size_t>(id), ex.what());+            }         }

cpp/tensorrt_llm/pybind/common/tllmExceptions.cpp (2)

33-41:Align Python exception’s fully-qualified name with its module.

You’re creating the type as "tensorrt_llm.RequestSpecificException" but adding it to the exceptions submodule. This leads to a mismatch between the qualified name and where it lives (tensorrt_llm.exceptions.RequestSpecificException).

Use the submodule’s name to build the exception’s FQN:

-    static PyObject* request_specific_exc-        = PyErr_NewException("tensorrt_llm.RequestSpecificException", nullptr, nullptr);+    const std::string exc_fqn = (std::string) py::str(m.attr("__name__")) + ".RequestSpecificException";+    static PyObject* request_specific_exc = PyErr_NewException(exc_fqn.c_str(), nullptr, nullptr);

---

1-15:Update copyright year.

Please update to include 2025 to align with other files and guidelines.

cpp/include/tensorrt_llm/common/tllmException.h (2)

1-3:Update copyright year.

Bring the header to 2025 per repository guidelines.

---

17-24:Consider adding an include guard as per guidelines.

Guidelines prefer include guards named TRTLLM_TLLMEXCEPTION_H. The file currently uses#pragma once. If the codebase standardizes on guards, consider adding them.

Example:

#ifndef TRTLLM_TLLMEXCEPTION_H#defineTRTLLM_TLLMEXCEPTION_H// ... contents ...#endif// TRTLLM_TLLMEXCEPTION_H

tensorrt_llm/_torch/pyexecutor/py_executor.py (4)

1-1:Missing NVIDIA copyright header

Per coding guidelines, prepend the NVIDIA copyright header (current year) to all source files.

Apply at the top of the file:

+ # Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.

---

890-895:Assertion on empty schedule in non-disaggregated mode: verify this cannot trigger under valid conditions

The new assert will hard-fail ifscheduled_batch.batch_size == 0 without a transceiver. This may legitimately happen (e.g., temporary resource contention or attention-DP balancing/pausing edge cases). Consider gating the assert to avoid false positives or convert to a warning with telemetry.

Suggested change:

-        else:-            assert scheduled_batch.batch_size > 0, (-                "fail to schedule any pending request, "-                "probably run out of resource.")+        else:+            # In non-disaggregated mode, assert we made forward progress;+            # avoid false positives when attention DP is balancing.+            if not self.enable_attention_dp:+                assert scheduled_batch.batch_size > 0, (+                    "fail to schedule any pending request, "+                    "probably run out of resource."+                )

---

1398-1417:Helper is solid; tighten annotations, adopt snake_case, and handle unknown request_id

• Add a precise callable type annotation and return type.
• Use snake_case forat_least_num to match Python conventions.
• If an exception carries an unknown/untrackedrequest_id, fall back to a global error (prevents stuck active requests).

-def _check_cache_transfer_status_helper(self,-                                        method_name: str,-                                        method_call,-                                        atLeastNum: int = 0):-    """Helper method to handle cache transfer status checking with error handling."""-    try:-        method_call(atLeastNum)+def _check_cache_transfer_status_helper(self,+                                        method_name: str,+                                        method_call: "Callable[[int], None]",+                                        at_least_num: int = 0) -> None:+    """Handle KV cache transfer status checking with per-request error propagation."""+    try:+        method_call(at_least_num)     except RequestSpecificException as e:-        error_msg = str(e)-        logger.error(-            f"Encountered a request-specific error in {method_name}: {error_msg}"-        )-        request_ids = [e.request_id]-        self._handle_errors(error_msg, request_ids)+        error_msg = str(e)+        logger.error(f"Encountered a request-specific error in {method_name}: {error_msg}")+        # If the id is not known locally, treat as a global error to avoid a stuck state.+        known_ids = {r.py_request_id for r in self.active_requests}+        request_ids = [e.request_id] if getattr(e, "request_id", None) in known_ids else None+        self._handle_errors(error_msg, request_ids)     except Exception as e:         error_msg = str(e)         logger.error(             f"Encountered a system error in {method_name}: {error_msg}")         self._handle_errors(error_msg)

Note: using a quoted type for Callable avoids adding new imports; feel free to import Callable if preferred.

---

1418-1429:Nit: adopt snake_case foratLeastNum across wrappers

Aligns with Python naming conventions. Semantics unchanged.

-@nvtx_range("_check_disagg_ctx_cache_transfer_status")-def _check_disagg_ctx_cache_transfer_status(self, atLeastNum: int = 0):-    self._check_cache_transfer_status_helper(-        "checking context transfer status",-        self.kv_cache_transceiver.check_context_transfer_status, atLeastNum)+@nvtx_range("_check_disagg_ctx_cache_transfer_status")+def _check_disagg_ctx_cache_transfer_status(self, at_least_num: int = 0):+    self._check_cache_transfer_status_helper(+        "checking context transfer status",+        self.kv_cache_transceiver.check_context_transfer_status, at_least_num)-@nvtx_range("_check_disagg_gen_cache_transfer_status")-def _check_disagg_gen_cache_transfer_status(self, atLeastNum: int = 0):-    self._check_cache_transfer_status_helper(-        "checking generation transfer status",-        self.kv_cache_transceiver.check_gen_transfer_status, atLeastNum)+@nvtx_range("_check_disagg_gen_cache_transfer_status")+def _check_disagg_gen_cache_transfer_status(self, at_least_num: int = 0):+    self._check_cache_transfer_status_helper(+        "checking generation transfer status",+        self.kv_cache_transceiver.check_gen_transfer_status, at_least_num)

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: zhengd-nvPR: NVIDIA/TensorRT-LLM#6633File: cpp/tensorrt_llm/batch_manager/dataTransceiverImpl.cpp:145-155Timestamp: 2025-08-06T08:18:28.669ZLearning: In cpp/tensorrt_llm/batch_manager/dataTransceiverImpl.cpp, the existing `mMtxForMap` mutex in DataSenderImpl is sufficient to synchronize measurement file operations in the `release` method, as all file operations occur within the same critical section that protects the `mRequestToSession` map access.

cpp/tensorrt_llm/batch_manager/dataTransceiver.h (2)

154-162:Missing include for RequestSpecificException

The code usescommon::RequestSpecificException andcommon::RequestErrorCode::kNETWORK_ERROR, but the header doesn't include the requiredtensorrt_llm/common/tllmException.h. Relying on transitive includes can lead to build failures.

Add the missing include near the other includes (outside the selected range):

#include"tensorrt_llm/common/tllmException.h"

---

167-175:Missing include for RequestSpecificException

Same issue as above - the required header is not included.

cpp/include/tensorrt_llm/common/tllmException.h (1)

29-31:Consider using a shorter macro name

As suggested by Shixiaowei02 in a previous review, the macro nameNEW_TLLM_REQUEST_SPECIFIC_EXCEPTION_WITH_ERROR_CODE is quite long. Consider a more concise name for better readability.

-#define NEW_TLLM_REQUEST_SPECIFIC_EXCEPTION_WITH_ERROR_CODE(requestID, errorCode, ...)                                 \+#define TLLM_REQUEST_EXCEPTION(requestID, errorCode, ...)                                                             \     tensorrt_llm::common::RequestSpecificException(                                                                    \         __FILE__, __LINE__, tensorrt_llm::common::fmtstr(__VA_ARGS__).c_str(), requestID, errorCode)

Note: If you apply this change, you'll need to update all usages of this macro throughout the codebase.

cpp/tensorrt_llm/nanobind/common/tllmExceptions.h (1)

17-17:Consider using include guards instead of#pragma once

The coding guidelines specify that header files must use include guards namedTRTLLM_<FILENAME>_H without underscores prefix/suffix. Replace#pragma once with traditional include guards.

-#pragma once+#ifndef TRTLLM_TLLMEXCEPTIONS_H+#define TRTLLM_TLLMEXCEPTIONS_H+ #include <nanobind/nanobind.h> namespace nb = nanobind; namespace tensorrt_llm::nanobind::common { void initExceptionsBindings(nb::module_& m); } // namespace tensorrt_llm::nanobind::common++#endif // TRTLLM_TLLMEXCEPTIONS_H

cpp/include/tensorrt_llm/common/tllmException.h (1)

37-44:Consider more specific error code categories

The current error code categories are quite broad. Consider adding more specific error codes for better diagnostics and error handling granularity. For example:

• Connection timeout vs. connection refused
• Data corruption vs. protocol mismatch
• Authentication failures

This would help users and developers better understand and handle specific error scenarios.

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: zhengd-nvPR: NVIDIA/TensorRT-LLM#6633File: cpp/tensorrt_llm/batch_manager/dataTransceiverImpl.cpp:145-155Timestamp: 2025-08-06T08:18:28.669ZLearning: In cpp/tensorrt_llm/batch_manager/dataTransceiverImpl.cpp, the existing `mMtxForMap` mutex in DataSenderImpl is sufficient to synchronize measurement file operations in the `release` method, as all file operations occur within the same critical section that protects the `mRequestToSession` map access.

cpp/include/tensorrt_llm/common/tllmException.h (1)

29-31:Provide a shorter alias for the macro (addresses prior feedback)

Echoing the earlier comment about macro length, consider adding a concise alias while keeping the current name for backward compatibility.

Apply this diff to add a short alias:

 #define TLLM_REQUEST_EXCEPTION(requestID, errorCode, ...)                                                              \     tensorrt_llm::common::RequestSpecificException(                                                                    \         __FILE__, __LINE__, tensorrt_llm::common::fmtstr(__VA_ARGS__).c_str(), requestID, errorCode)++// Short alias to reduce verbosity at call sites, keeps the original for compatibility.+#define TLLM_REQ_EXCEPTION(requestID, errorCode, ...)                                                                  \+    TLLM_REQUEST_EXCEPTION(requestID, errorCode, __VA_ARGS__)

tensorrt_llm/_torch/pyexecutor/py_executor.py (1)

1539-1561:Fix: _handle_errors builds wrong structure and mutates active_requests during iteration

• It constructs a dict but _enqueue_responses expects an iterable of (req_id, LlmResponse) tuples. This will raise “cannot unpack non-iterable int object.”
• It removes from self.active_requests while iterating over it, causing skipped elements and inconsistent state.

This was raised previously and is still present. Also, the AI summary claims call sites were updated to use request_ids but _respond_if_invalid still passes requests=[request].

Apply this diff to fix structure and removal logic:

-    def _handle_errors(self,-                       error_msg: Optional[str] = None,-                       request_ids: Optional[List[int]] = None):-        error_responses = {}-        error_msg = error_msg or "error"-        for request in self.active_requests:-            if request_ids is not None and request.py_request_id not in request_ids:-                continue-            req_id = request.py_request_id-            request.state = LlmRequestState.GENERATION_COMPLETE-            self._terminate_request(request)-            error_responses[req_id] = LlmResponse(-                request_id=req_id,-                error_msg=error_msg,-                client_id=request.py_client_id)--        if request_ids is not None:-            req_id_set = set(request_ids)-            for request in self.active_requests:-                if request.py_request_id in req_id_set:-                    self.active_requests.remove(request)-        else:-            self.active_requests.clear()-        self._enqueue_responses(error_responses)+    def _handle_errors(+        self,+        error_msg: Optional[str] = None,+        request_ids: Optional[List[int]] = None,+    ) -> None:+        error_msg = error_msg or "error"+        error_responses: List[Tuple[int, LlmResponse]] = []+        matched_requests: List[LlmRequest] = []+        for request in self.active_requests:+            if request_ids is not None and request.py_request_id not in request_ids:+                continue+            matched_requests.append(request)+            req_id = request.py_request_id+            request.state = LlmRequestState.GENERATION_COMPLETE+            self._terminate_request(request)+            error_responses.append((+                req_id,+                LlmResponse(+                    request_id=req_id,+                    error_msg=error_msg,+                    client_id=request.py_client_id,+                ),+            ))++        if request_ids is not None:+            req_id_set = set(request_ids)+            self.active_requests = [+                req for req in self.active_requests+                if req.py_request_id not in req_id_set+            ]+        else:+            self.active_requests.clear()+        self._enqueue_responses(error_responses)

Additionally, update call sites still using the old parameter name. For example, in _respond_if_invalid:

# beforeself._handle_errors(str(e),requests=[request])# afterself._handle_errors(str(e),request_ids=[request.py_request_id])

I can send a targeted patch for other call sites if you prefer. Do you want me to sweep the repo for any remaining uses of the old “requests=” keyword and open a follow-up PR?

cpp/include/tensorrt_llm/common/tllmException.h (3)

36-44:Enum design looks good; optional: consider signed underlying type

The reserved ranges and explicit underlying type are clear. If you want to strictly follow the “prefer signed integers” guideline, you could use int32_t as the underlying type. If the bindings or formatting pathways expect unsigned, keeping uint32_t is fine as-is.

---

67-83:Make members const and align identifier casing (Id vs ID); tighten pointer constness

Minor polish to improve const-correctness and naming consistency with lowerCamelCase:

• Make mRequestID and mErrorCode const (they are immutable after construction).
• Use requestId for parameter/member naming consistency with lowerCamelCase.
• Use char const* const for the message pointer (pointer itself is not modified).

-class RequestSpecificException : public std::runtime_error+class RequestSpecificException : public std::runtime_error { public:     explicit RequestSpecificException(-        std::string const& file, std::size_t line, char const* msg, uint64_t requestID, RequestErrorCode errorCode);+        std::string const& file, std::size_t line, char const* const msg, uint64_t requestId, RequestErrorCode errorCode);      ~RequestSpecificException() noexcept override;      [[nodiscard]] uint64_t getRequestId() const noexcept;      [[nodiscard]] RequestErrorCode getErrorCode() const noexcept;  private:-    uint64_t mRequestID;-    RequestErrorCode mErrorCode;+    uint64_t const mRequestId;+    RequestErrorCode const mErrorCode; };

Note: Update the corresponding definitions in cpp/tensorrt_llm/common/tllmException.cpp and any call sites to use requestId/mRequestId.

---

67-83:Consider deriving from TllmException for stack-trace parity

If you want per-request exceptions to carry the same stack trace/debugging features as TllmException, consider inheriting from TllmException instead of std::runtime_error. This keeps a consistent exception hierarchy and tooling.

Illustrative header diff:

-class RequestSpecificException : public std::runtime_error+class RequestSpecificException : public TllmException { public:     explicit RequestSpecificException(-        std::string const& file, std::size_t line, char const* msg, uint64_t requestID, RequestErrorCode errorCode);+        std::string const& file, std::size_t line, char const* const msg, uint64_t requestId, RequestErrorCode errorCode);

The cpp ctor would then call TllmException(file.c_str(), line, composedMsg) as the base, while still storing requestId and errorCode. If minimizing overhead is a goal, keeping std::runtime_error is reasonable—this is an optional alignment decision.

tensorrt_llm/_torch/pyexecutor/py_executor.py (3)

11-11:Add missing typing imports (Callable, Any) and ensure file has NVIDIA copyright header

• You’ll likely want Callable/Any for the helper’s type hints below.
• Per coding guidelines, prepend the NVIDIA copyright header (current year) to this file.

Apply this diff to extend typing imports:

-from typing import Iterable, List, Optional, Tuple, Union+from typing import Iterable, List, Optional, Tuple, Union, Callable, Any

---

891-895:Prefer explicit exception over assert for production behavior

assert can be stripped with Python optimizations (-O), silently removing the check. Throw a RuntimeError (or a domain-specific exception) instead.

-        else:-            assert scheduled_batch.batch_size > 0, (-                "fail to schedule any pending request, "-                "probably run out of resource.")+        else:+            if scheduled_batch.batch_size <= 0:+                raise RuntimeError(+                    "fail to schedule any pending request, probably run out of resource."+                )

---

1398-1429:Solid centralization; align naming with snake_case and add minimal typing/logging enhancements

• Rename atLeastNum to at_least_num (PEP8).
• Type method_call to Callable[[int], Any] and add a return type.
• Optionally log error_code if present on the exception to aid triage.

-    def _check_cache_transfer_status_helper(self,-                                            method_name: str,-                                            method_call,-                                            atLeastNum: int = 0):-        """Helper method to handle cache transfer status checking with error handling."""+    def _check_cache_transfer_status_helper(+        self,+        method_name: str,+        method_call: Callable[[int], Any],+        at_least_num: int = 0,+    ) -> None:+        """Helper to check cache-transfer status with per-request and system error handling."""         try:-            method_call(atLeastNum)+            method_call(at_least_num)         except RequestSpecificException as e:             error_msg = str(e)-            logger.error(-                f"Encountered a request-specific error in {method_name}: {error_msg}"-            )-            request_ids = [e.request_id]-            self._handle_errors(error_msg, request_ids)+            # Log error_code if exposed by the binding (best-effort)+            err_code = getattr(e, "error_code", None)+            rid = getattr(e, "request_id", None)+            extra = f" [request_id={rid}, error_code={err_code}]" if rid is not None else ""+            logger.error(f"Encountered a request-specific error in {method_name}: {error_msg}{extra}")+            self._handle_errors(error_msg, [rid] if rid is not None else None)         except Exception as e:             error_msg = str(e)             logger.error(                 f"Encountered a system error in {method_name}: {error_msg}")             self._handle_errors(error_msg)-    @nvtx_range("_check_disagg_ctx_cache_transfer_status")-    def _check_disagg_ctx_cache_transfer_status(self, atLeastNum: int = 0):+    @nvtx_range("_check_disagg_ctx_cache_transfer_status")+    def _check_disagg_ctx_cache_transfer_status(self, at_least_num: int = 0) -> None:         self._check_cache_transfer_status_helper(             "checking context transfer status",-            self.kv_cache_transceiver.check_context_transfer_status, atLeastNum)+            self.kv_cache_transceiver.check_context_transfer_status, at_least_num)-    @nvtx_range("_check_disagg_gen_cache_transfer_status")-    def _check_disagg_gen_cache_transfer_status(self, atLeastNum: int = 0):+    @nvtx_range("_check_disagg_gen_cache_transfer_status")+    def _check_disagg_gen_cache_transfer_status(self, at_least_num: int = 0) -> None:         self._check_cache_transfer_status_helper(             "checking generation transfer status",-            self.kv_cache_transceiver.check_gen_transfer_status, atLeastNum)+            self.kv_cache_transceiver.check_gen_transfer_status, at_least_num)

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

cpp/include/tensorrt_llm/common/tllmException.h (1)

40-43:Add a short alias and a throw-helper for request exceptions (echoing prior feedback on macro length)

A shorter alias improves ergonomics, and a throw-helper matchesTLLM_THROW. Keep the existing macro for compatibility and add non-breaking helpers.

 #define TLLM_REQUEST_EXCEPTION(requestID, errorCode, ...)                                                              \     tensorrt_llm::common::RequestSpecificException(                                                                    \         __FILE__, __LINE__, tensorrt_llm::common::fmtstr(__VA_ARGS__).c_str(), requestID, errorCode)++// Short alias and throw-helper for request-scoped exceptions.+#define TLLM_REQ_EXCEPTION(requestId, errorCode, ...)                                                                  \+    TLLM_REQUEST_EXCEPTION(requestId, errorCode, __VA_ARGS__)+#define TLLM_THROW_REQUEST(requestId, errorCode, ...)                                                                  \+    do                                                                                                                 \+    {                                                                                                                  \+        throw TLLM_REQ_EXCEPTION(requestId, errorCode, __VA_ARGS__);                                                   \+    } while (0)

cpp/include/tensorrt_llm/common/tllmException.h (3)

17-17:Guideline check: include guards vs. pragma once

The project guideline mandates header include guards named TRTLLM__H. This file uses only#pragma once. If the codebase standardizes on#pragma once, ignore this; otherwise, consider adding guards for consistency and portability.

Example guard for this file:

#ifndef TRTLLM_TLLM_EXCEPTION_H#defineTRTLLM_TLLM_EXCEPTION_H// ... file content ...#endif// TRTLLM_TLLM_EXCEPTION_H

---

47-47:Use Doxygen//! per project style

Switch/// @brief comments to//! to match documented style.

-/// @brief Enumeration of different error codes for request-specific exceptions+//! Enumeration of different error codes for request-specific exceptions@@-/// @brief Constant for unknown request ID+//! Constant for unknown request ID

Also applies to: 57-57

---

88-104:Align “Id” casing and constructor signature; consider consistency with TllmException

• Naming: method isgetRequestId() but members/params userequestID/mRequestID. Prefer lowerCamelCaseId everywhere.
• Signature:file ischar const* inTllmException butstd::string const& here. Usingchar const* avoids constructing a temporary std::string for__FILE__ and keeps APIs consistent.

Apply in-header changes:

 class RequestSpecificException : public std::runtime_error { public:-    explicit RequestSpecificException(-        std::string const& file, std::size_t line, char const* msg, uint64_t requestID, RequestErrorCode errorCode);+    explicit RequestSpecificException(+        char const* file, std::size_t line, char const* msg, uint64_t requestId, RequestErrorCode errorCode);@@-    [[nodiscard]] uint64_t getRequestId() const noexcept;+    [[nodiscard]] uint64_t getRequestId() const noexcept;@@ private:-    uint64_t mRequestID;+    uint64_t mRequestId;     RequestErrorCode mErrorCode; };

And update the implementation accordingly (outside this header):

// cpp/tensorrt_llm/common/tllmException.cpp// Constructor signature change (file: char const*, requestId name) and member rename.RequestSpecificException::RequestSpecificException(charconst* file, std::size_t line,charconst* msg,uint64_t requestId, RequestErrorCode errorCode)    : std::runtime_error{fmtstr("%s (Request ID: %" PRIu64", Error Code: %u) (%s:%zu)",          msg, requestId,static_cast<uint32_t>(errorCode), file, line)}    ,mRequestId{requestId}    ,mErrorCode{errorCode}{}

Optional design note: if much of the codebase catchesTllmException to leverage backtraces, consider derivingRequestSpecificException fromTllmException instead ofstd::runtime_error for consistency. If consumers already catchstd::exception or you wish to avoid callstack capture overhead, the current base is fine—just confirm catch sites.

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

cpp/tensorrt_llm/nanobind/common/tllmExceptions.cpp (1)

54-56:Cast error_code to the bound Python enum, not uint32_t.

This preserves enum semantics on the Python side and matches how RequestErrorCode is exported.

-                nb::object error_code = nb::cast(static_cast<uint32_t>(e.getErrorCode()));+                nb::object error_code = nb::cast(e.getErrorCode());

cpp/tensorrt_llm/nanobind/common/tllmExceptions.cpp (3)

1-15:Update copyright year to current year (2025).

Coding guidelines require prepending the NVIDIA copyright header with the current year. Please update 2022-2024 → 2022-2025.

- * Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.+ * Copyright (c) 2022-2025, NVIDIA CORPORATION.  All rights reserved.

---

36-41:Avoid function-local static nb::object; use lowerCamelCase and remove the lifetime hazard.

• Function-local static nb::object can have teardown ordering issues at interpreter shutdown (nb::object dtor after Python finalization). It’s safer not to keep it static.
• Local variable naming should use lowerCamelCase (coding guidelines).
• You can avoid holding the type at all by using the instance’s type in PyErr_SetObject.

Apply this diff:

-    // Create the RequestSpecificException Python exception class-    static nb::object request_specific_exc = nb::exception<tc::RequestSpecificException>(m, "RequestSpecificException");+    // Create the RequestSpecificException Python exception class+    nb::object requestSpecificExc = nb::exception<tc::RequestSpecificException>(m, "RequestSpecificException");-    // Add attributes to the Python exception class-    request_specific_exc.attr("request_id") = nb::none();-    request_specific_exc.attr("error_code") = nb::none();+    // Add attributes to the Python exception class+    requestSpecificExc.attr("request_id") = nb::none();+    requestSpecificExc.attr("error_code") = nb::none();-                PyErr_SetObject(request_specific_exc.ptr(), py_exc.ptr());+                // Use the actual exception instance type to raise+                PyErr_SetObject(Py_TYPE(py_exc.ptr()), py_exc.ptr());

Also applies to: 62-62

---

42-65:Optional: simplify translator signature by removing the unused void argument.*

If nanobind in this repo supports the single-argument translator overload, dropping the unused parameter clarifies intent. Otherwise, ignore.

-    nb::register_exception_translator(-        [](std::exception_ptr const& p, void*)+    nb::register_exception_translator(+        [](std::exception_ptr const& p)         {             try             {                 if (p)                     std::rethrow_exception(p);             }             catch (const tc::RequestSpecificException& e)             {                 // ...             }-        });+        });

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.