Add KernelInfo string-array attribute APIs to the ORT C and C++ APIs

[tianleiwu]

Summary

This PR adds a new OrtApi entry point for reading repeated string attributes from OrtKernelInfo:

• KernelInfoGetAttributeArray_string

It also wires that support through the C++ wrapper so callers can use:

• Ort::ConstKernelInfo::GetAttributes<std::string>(...)

Problem

The existing kernel info APIs already support scalar and array attribute access for numeric types, but there was no C API for reading string-array attributes from OrtKernelInfo.

That created a gap for code paths that rely on repeated string attributes in kernel metadata, such as:

• custom op / kernel consumers using the public C API
• C++ wrapper callers expecting GetAttributes<std::string> to work end-to-end
• plugin EP scenarios that need to compile existing kernels against the adapter/C API surface

One concrete case is CUDA plugin EP RNN support, where the RNN kernels read the activations attribute via GetAttrs<std::string>("activations", ...). The adapter path needed a corresponding ORT C API to expose that data.

Changes

C API

Added OrtApi::KernelInfoGetAttributeArray_string to fetch repeated string attributes from OrtKernelInfo.

Behavior:

• If out == nullptr, the API returns the attribute count in size.
• Otherwise, the API allocates the pointer array and each UTF-8 string with the provided OrtAllocator.
• For empty attributes, *out is set to nullptr and *size is set to 0.
• The caller frees each string and the pointer array with the same allocator.

Implementation

Added the implementation in the ORT session/custom-op API layer by:

• reading the underlying attribute with OpKernelInfo::GetAttrs<std::string>
• copying the result into allocator-owned C-style string storage for the public API

C++ wrapper

Completed C++ wrapper support so Ort::ConstKernelInfo::GetAttributes<std::string>(name) works through the new C API.

The wrapper follows the standard two-call pattern:

1. query the number of strings
2. allocate and fetch the returned string array
3. copy into std::vector<std::string> and release allocator-owned memory

Tests

Added framework tests covering:

• non-empty string-array attributes
• empty string-array attributes
• missing attribute failure path
• C++ wrapper access through Ort::ConstKernelInfo

Files Changed

• include/onnxruntime/core/session/onnxruntime_c_api.h
• include/onnxruntime/core/session/onnxruntime_cxx_api.h
• include/onnxruntime/core/session/onnxruntime_cxx_inline.h
• onnxruntime/core/session/custom_ops.cc
• onnxruntime/core/session/onnxruntime_c_api.cc
• onnxruntime/core/session/ort_apis.h
• onnxruntime/test/framework/kernel_info_test.cc

Why This Change

This closes a real API gap in kernel attribute access and makes the public API surface more consistent with the existing numeric attribute helpers.

It also unblocks plugin/adapter-based kernel code that depends on repeated string attributes without requiring those kernels to special-case plugin builds.

For example, porting rnn operator to cuda plugin EP will need this API.

Validation

Validated with new unit coverage in kernel_info_test.cc for:

• KernelInfoGetAttributeArray_string with populated attributes
• KernelInfoGetAttributeArray_string with empty attributes
• missing-attribute error handling
• Ort::ConstKernelInfo::GetAttributes<std::string> parity with the C API

[github-actions]

You can commit the suggested changes from lintrunner.

[Copilot]

Pull request overview

This PR adds public ORT C/C++ API support for reading repeated (array) string attributes from OrtKernelInfo, closing a gap vs. existing numeric attribute array APIs and unblocking scenarios like plugin EP kernels that depend on repeated string attributes.

Changes:

• Adds OrtApi::KernelInfoGetAttributeArray_string (allocator-allocated char** + per-string buffers) and wires it into the C API dispatch table.
• Implements the new API in the custom-op/kernel-info API layer by reading OpKernelInfo::GetAttrs<std::string> and copying results to allocator-owned C strings.
• Extends the C++ wrapper to support Ort::ConstKernelInfo::GetAttributes<std::string>(...) and adds new gtest coverage.

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
include/onnxruntime/core/session/onnxruntime_c_api.h	Declares the new C API entry point and documents usage/freeing semantics.
onnxruntime/core/session/ort_apis.h	Adds the OrtApis::KernelInfoGetAttributeArray_string declaration.
onnxruntime/core/session/onnxruntime_c_api.cc	Wires the new function into the v1–v25 OrtApi function table and adds an ABI offset assert.
onnxruntime/core/session/custom_ops.cc	Implements the new KernelInfo string-array accessor and allocation/copy helper.
include/onnxruntime/core/session/onnxruntime_cxx_api.h	Extends the C++ wrapper API surface to support string arrays in GetAttributes.
include/onnxruntime/core/session/onnxruntime_cxx_inline.h	Implements attr_utils::GetAttrs(..., std::vector<std::string>&) using the new C API.
onnxruntime/test/framework/kernel_info_test.cc	Adds unit tests for non-empty/empty/missing string-array attributes and C++ wrapper parity.

Comments suppressed due to low confidence (1)

include/onnxruntime/core/session/onnxruntime_cxx_api.h:2892

• The template parameter R for GetAttributes is the element type (e.g., float, int64_t, std::string), not a vector type. The comment currently says std::vector<float>/etc., which is misleading—please update it to match the GetAttribute comment above.

  template <typename R>  // R is only implemented for std::vector<float>, std::vector<int64_t>, and std::vector<std::string>
  std::vector<R> GetAttributes(const char* name) const {
    std::vector<R> result;
    attr_utils::GetAttrs(this->p_, name, result);
    return result;

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

You can also share your feedback on Copilot code review. Take the survey.