Rust errors and features

Crate: aic-sdk = "=0.24.0". Core SDK: 0.24.0. The minimum Rust version is 1.88, using edition 2024. Source: the published aic-sdk and aic-sdk-sys crates.

Cargo features

No features are enabled by default. Static native linking is the default strategy, but a native library must still be supplied. Cargo features are additive across dependencies.

Feature	Available API and build behavior
`async`	Exposes `ProcessorAsync` and `VadAsync`, using a shared Rayon worker pool and per-instance async mutex
`download-model`	Adds `Model::download`; otherwise this associated function is absent
`download-lib`	Permits the build script to download the matching native library when `AIC_LIB_PATH` is absent and build-time linking is selected
`dynamic-linking`	Uses a shared library with build-time linking; deploy the runtime library as well as the executable
`runtime-linking`	Resolves the shared library at runtime; exposes `load_library`, `is_library_loaded` and `DynamicLoadingError`, and skips the native build-time link/download step

If both linking features are enabled, runtime linking wins and the build emits a warning. Prefer selecting one explicitly. AIC_LIB_PATH identifies the SDK library directory for static/dynamic build-time linking; it is not the runtime load_library file path. With no download feature, build-time linking requires a local library. See the released linking guide for platform deployment details. For runtime loading and async processing, a minimal dependency declaration is:

[dependencies]
aic-sdk = { version = "=0.24.0", features = ["runtime-linking", "async"] }

load_library

Requires feature: runtime-linking.

pub unsafe fn load_library<P: AsRef<std::path::Path>>(
    path: P,
) -> Result<(), DynamicLoadingError>

Explicitly loads a native shared library before the first SDK operation. Safety: the file must be trusted and ABI-compatible with the bundled 0.24.0 header. Loading an incompatible library can cause undefined behavior. Checking a filename or a version string after loading does not establish ABI compatibility. The loaded library remains for the process lifetime. It cannot be safely replaced. A subsequent valid load returns AlreadyLoaded; the implementation attempts opening and resolving the supplied library before storing it, so an invalid subsequent path can return an open/symbol error first. If you omit this call, the first SDK operation loads the platform default filename through the OS loader search path (libaic.so, libaic.dylib or aic.dll). Automatic loading failure panics. Explicit loading lets you handle DynamicLoadingError before SDK use.

is_library_loaded

Requires feature: runtime-linking.

pub fn is_library_loaded() -> bool

Reports whether this process has installed the SDK dynamic library. It does not trigger loading or prove SDK authorization.

DynamicLoadingError

Requires feature: runtime-linking. Reexported from aic_sdk_sys.

pub enum DynamicLoadingError {
    AlreadyLoaded,
    OpenLibrary {
        path: std::path::PathBuf,
        source: libloading::Error,
    },
    LoadSymbol {
        symbol: &'static str,
        source: libloading::Error,
    },
}

Variant	Meaning and recovery
`AlreadyLoaded`	A library was already installed; use the existing library or restart with the intended build
`OpenLibrary { path, source }`	The loader could not open the file; check the exact path, architecture and dependent libraries
`LoadSymbol { symbol, source }`	A required symbol is missing; supply the matching complete native SDK

All named variant fields are public pattern-match payloads with the types shown above. path identifies the attempted file and symbol the missing native function. Both source fields preserve the platform loader error. The enum implements Debug, Display and std::error::Error; Error::source() returns the underlying loader error for the two payload variants and None for AlreadyLoaded. It is not Clone or Eq.

AicError

pub enum AicError {
    ParameterOutOfRange,
    NotInitialized,
    AudioConfigUnsupported,
    AudioConfigMismatch,
    ProcessingNotAllowed,
    Internal,
    LicenseFormatInvalid,
    LicenseVersionUnsupported,
    LicenseExpired,
    TokenUpdateUnsupported,
    ModelInvalid,
    ModelVersionUnsupported,
    ModelTypeUnsupported,
    FilePathInvalid,
    FileSystemError,
    ModelDataUnaligned,
    ModelDownload(String),
    Unknown(aic_sdk_sys::AicErrorCode::Type),
}

Returned by fallible wrapper operations. Implements Debug, Clone, PartialEq, Eq, Display and std::error::Error. Display provides diagnostic text; match variants rather than parsing those strings. ModelDownload carries text rather than a nested error source.

Variant	Cause and recovery
`ParameterOutOfRange`	Parameter outside its bounds; use the documented ranges and read the current value
`NotInitialized`	Processing/buffering before successful initialization; initialize the object first
`AudioConfigUnsupported`	Invalid rate/block combination, or zero FileAnalyzer rate/step; start with the model’s optimal configuration
`AudioConfigMismatch`	Slice length violates the initialized block contract; split or buffer samples appropriately
`ProcessingNotAllowed`	Authorization/reporting failed or a termination signal was handled; check credentials/network and apply your explicit audio fallback
`Internal`	Native internal failure, including a NUL-containing telemetry session ID; correct input or report a minimal reproduction
`LicenseFormatInvalid`	Malformed credential or embedded NUL; verify the exact SDK key/JWT without logging it
`LicenseVersionUnsupported`	Unsupported credential format; use a compatible SDK and credential
`LicenseExpired`	Credential expired; renew it and rotate JWTs before expiry when supported
`TokenUpdateUnsupported`	Original or replacement credential is not a JWT; start with JWT credentials when rotation is required
`ModelInvalid`	Corrupted/invalid model data; obtain a verified model file
`ModelVersionUnsupported`	Model file format differs from the core SDK; download compatible data
`ModelTypeUnsupported`	Wrong model family for processor, VAD or analyzer; select a matching model
`FilePathInvalid`	Native path invalid; validate paths before loading. Embedded NUL in `Model::from_file` instead panics in this wrapper release
`FileSystemError`	Model file cannot be read; check existence, type and permissions
`ModelDataUnaligned`	Buffer address is not 64-byte aligned; use `include_model!` or a correctly aligned allocation
`ModelDownload(String)`	Manifest/model/file operation failed; inspect the payload and check model ID, connectivity and destination permissions
`Unknown(AicErrorCode::Type)`	Unrecognized native code; record the code and versions for investigation

The tuple payloads are available through pattern matching. ModelDownload exists even with download-model disabled, although the public downloader is then absent. There is no ParameterFixed variant in this release.

Panics and Result boundaries

Result covers ordinary native errors but is not a promise that no call can panic. Model/query/context functions assert native success. Model::from_file panics on an embedded NUL path. Worker initialization or unexpected worker channel loss can panic in async code. Runtime automatic loading can panic before the called SDK operation returns. Explicit loader handling and validated inputs keep these conditions distinct from routine processing errors.

Trait and conversion surface

Types	Explicit or derived traits
`Model<'a>`, `Processor<'a>`, `ProcessorContext`, `Vad<'a>`, `VadContext`, `Collector`, `Analyzer<'a>`	`Drop`, `Send`, `Sync`; native handles are released on drop
`ProcessorAsync`, `VadAsync`	`Send` and `Sync` through owned synchronized fields; use `Arc` rather than assuming `Clone`
`FileAnalyzer<'model, 'a>`	`Send`/`Sync` through its borrowed model and owned fields; field destruction releases the pair
`ProcessorConfig`, `OtelConfig`	`Debug`, `Clone`, `PartialEq`, `Eq`, `Hash`; no `Default` or `Copy`
`ProcessorParameter`, `VadParameter`	`Debug`, `Clone`, `Copy`, `PartialEq`, `Eq`, `Hash`
`AnalysisResult`	`Debug`, `Clone`, `PartialEq`; no `Eq` because it contains floating-point scores
`AicError`	`Debug`, `Clone`, `PartialEq`, `Eq`, `Display`, `Error`
`DynamicLoadingError`	`Debug`, `Display`, `Error`, behind `runtime-linking`

Explicit conversions are:

impl From<ProcessorParameter> for aic_sdk_sys::AicProcessorParameter::Type
impl From<VadParameter> for aic_sdk_sys::AicVadParameter::Type
impl From<aic_sdk_sys::AicAnalysisResult> for AnalysisResult
impl From<aic_sdk_sys::AicErrorCode::Type> for AicError

Parameter conversions map the named variant to its C enum value. Result conversion copies all seven fields. Error conversion maps known failure codes and wraps other values in Unknown; the null-pointer error code panics as a wrapper invariant failure. Do not convert a native success code into an error: this conversion does not perform the success check used by fallible SDK methods. Naming the aic_sdk_sys types in application code requires that crate as a direct dependency; they are not root type reexports of aic_sdk. Rustdoc also lists standard blanket traits and other compiler-derived implementations.

Reserved integration hook: set_sdk_id

pub unsafe fn set_sdk_id(id: u32)

This public export is reserved for ai-coustics wrapper integrations, not application setup. Callers must use an ID assigned by ai-coustics. Application constructors already identify the Rust wrapper; do not override it. See the symbol index, authentication and troubleshooting.

SDK

API reference

Upgrades

LiveKit

AI tools

Historical migrations

Cargo features

load_library

is_library_loaded

DynamicLoadingError

AicError

Panics and Result boundaries

Trait and conversion surface

Reserved integration hook: set_sdk_id

​Cargo features

​load_library

​is_library_loaded

​DynamicLoadingError

​AicError

​Panics and Result boundaries

​Trait and conversion surface

​Reserved integration hook: set_sdk_id

Cargo features

load_library

is_library_loaded

DynamicLoadingError

AicError

Panics and Result boundaries

Trait and conversion surface

Reserved integration hook: set_sdk_id