feat: Add KV publisher and receiver. Add KV aware routing example.

Signed-off-by: Neelay Shah <neelays@nvidia.com>
Co-authored-by: aflowers <aflowers@nvidia.com>
Co-authored-by: Ryan McCormick <rmccormick@nvidia.com>
Co-authored-by: hongkuanz <hongkuanz@nvidia.com>
Co-authored-by: Neelay Shah <neelays@nvidia.com>

examples/python_rs/llm/vllm/kv_router/router.py

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import asyncio
+import uuid
+from argparse import Namespace
+from enum import Enum
+
+import uvloop
+from common.protocol import Response, TokenizedRequest
+from triton_distributed_rs import (
+    DistributedRuntime,
+    KvRouter,
+    triton_endpoint,
+    triton_worker,
+)
+from vllm.logger import logger as vllm_logger
+
+
+class RoutingStrategy(Enum):
+    PREFIX = "prefix"
+    ROUND_ROBIN = "round_robin"
+    RANDOM = "random"
+
+
+class Router:
+    """
+    Request handler for the generate endpoint
+    """
+
+    def __init__(
+        self,
+        router,
+        workers_client,
+        routing_strategy: RoutingStrategy = RoutingStrategy.PREFIX,
+    ):
+        vllm_logger.info(
+            f"Initializing KV Router with strategy: {routing_strategy.value}"
+        )
+        self.router = router
+        self.workers_client = workers_client
+        self.routing_strategy = routing_strategy
+
+    @triton_endpoint(TokenizedRequest, Response)
+    async def generate(self, request):
+        lora_id = 0
+        worker_id = ""
+        if self.routing_strategy == RoutingStrategy.PREFIX:
+            try:
+                worker_id = await self.router.schedule(request.tokens, lora_id)
+            except Exception as e:
+                vllm_logger.info(f"{e}")
+                if "No worker found" in str(e):
+                    worker_id = ""
+                else:
+                    vllm_logger.exception(f"Error during worker selection: {e}")
+
+            vllm_logger.info(f"Scheduling to worker_id: {worker_id}")
+
+        if self.routing_strategy == RoutingStrategy.ROUND_ROBIN:
+            engine_generator = await self.workers_client.round_robin(
+                request.model_dump_json()
+            )
+        elif self.routing_strategy == RoutingStrategy.RANDOM or worker_id == "":
+            engine_generator = await self.workers_client.random(
+                request.model_dump_json()
+            )
+        else:
+            # extract back lease_id
+            engine_generator = await self.workers_client.direct(
+                request.model_dump_json(), uuid.UUID(worker_id).int
+            )
+
+        async for resp in engine_generator:
+            resp = resp.data() if hasattr(resp, "data") else resp
+            yield resp
+
+
+@triton_worker()
+async def worker(runtime: DistributedRuntime, args: Namespace):
+    workers_client = (
+        await runtime.namespace("triton-init")
+        .component("vllm")
+        .endpoint("generate_from_tokens")
+        .client()
+    )
+    vllm_logger.info("Waiting for workers to be ready")
+    await workers_client.wait_for_endpoints()
+
+    while len(workers_client.endpoint_ids()) < args.min_workers:
+        vllm_logger.info(
+            f"Waiting for more workers... Current: {len(workers_client.endpoint_ids())}, Required: {args.min_workers}"
+        )
+        await asyncio.sleep(5)
+
+    vllm_logger.info(
+        f"Required number of workers ({args.min_workers}) are ready:\n"
+        + "\n".join(f"id: {id}" for id in workers_client.endpoint_ids())
+    )
+
+    # TODO Router is a fixed namespace separate from the others
+    kv_listener = runtime.namespace("router").component(
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+    )
+    await kv_listener.create_service()
+
+    router_component = runtime.namespace("triton-init").component("router")
+    await router_component.create_service()
+
+    router = None
+    if args.routing_strategy == RoutingStrategy.PREFIX:
+        router = KvRouter(runtime, kv_listener)
+
+    endpoint = router_component.endpoint("generate")
+    await endpoint.serve_endpoint(
+        Router(router, workers_client, args.routing_strategy).generate
+    )
+
+
+if __name__ == "__main__":
+    uvloop.install()
+
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--routing-strategy",
+        type=RoutingStrategy,
+        default=RoutingStrategy.PREFIX,
+        choices=list(RoutingStrategy),
+        help="Routing strategy to use",
+    )
+    parser.add_argument(
+        "--min-workers",
+        type=int,
+        default=1,
+        help="Minimum number of workers required before proceeding",
+    )
+    args = parser.parse_args()
+
+    asyncio.run(worker(args))

examples/python_rs/llm/vllm/kv_router/worker.py

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import os
+import uuid
+from typing import Optional
+
+import uvloop
+import vllm
+from common.parser import parse_vllm_args
+from common.protocol import Request, Response, TokenizedRequest
+from triton_distributed_rs import (
+    DistributedRuntime,
+    KvRouter,
+    triton_endpoint,
+    triton_worker,
+)
+from vllm.engine.arg_utils import AsyncEngineArgs
+from vllm.inputs import TokensPrompt
+from vllm.logger import logger as vllm_logger
+from vllm.transformers_utils.tokenizer import AnyTokenizer
+
+vllm_logger.info(f"VLLM_KV_CAPI_PATH: {os.environ['VLLM_KV_CAPI_PATH']}")
+
+
+class VllmEngine:
+    """
+    Request handler for the generate endpoint
+    """
+
+    def __init__(self, engine_args: AsyncEngineArgs, router: KvRouter):
+        self.engine = vllm.AsyncLLMEngine.from_engine_args(engine_args)
+        self.router = router
+        self.tokenizer: Optional[AnyTokenizer] = None
+
+    # Pattern to initialize async object as python __init__ is not async
+    async def init(self):
+        self.tokenizer = await self.engine.get_tokenizer()
+        return self
+
+    @triton_endpoint(TokenizedRequest, Response)
+    async def generate_from_tokens(self, request):
+        tokens_prompt = TokensPrompt(prompt_token_ids=request.tokens)
+
+        sampling_params = vllm.SamplingParams(**request.sampling_params)
+        request_id = str(uuid.uuid4())
+        async for response in self.engine.generate(
+            tokens_prompt, sampling_params, request_id
+        ):
+            yield response.outputs[0].text
+
+    @triton_endpoint(Request, Response)
+    async def generate_from_prompt(self, request):
+        sampling_params = vllm.SamplingParams(**request.sampling_params)
+        request_id = str(uuid.uuid4())
+        async for response in self.engine.generate(
+            request.prompt, sampling_params, request_id
+        ):
+            yield response.outputs[0].text
+
+    @triton_endpoint(Request, Response)
+    async def preprocess(self, request):
+        if self.tokenizer is None:
+            raise RuntimeError("Tokenizer not initialized. Must run init().")
+        tokens = self.tokenizer.encode(request.prompt)
+
+        engine_generator = await self.router.generate(
+            TokenizedRequest(tokens=tokens, **request.model_dump()).model_dump_json()
+        )
+
+        async for resp in engine_generator:
+            yield resp.data()
+
+
+@triton_worker()
+async def worker(runtime: DistributedRuntime, engine_args: AsyncEngineArgs):
+    """
+    Instantiate a `backend` component and serve the `generate` endpoint
+    A `Component` can serve multiple endpoints
+    """
+    worker_component = runtime.namespace("triton-init").component("vllm")
+    await worker_component.create_service()
+
+    preprocess_component = runtime.namespace("triton-init").component("preprocess")
+    await preprocess_component.create_service()
+
+    router_client = (
+        await runtime.namespace("triton-init")
+        .component("router")
+        .endpoint("generate")
+        .client()
+    )
+
+    worker_from_tokens_endpoint = worker_component.endpoint("generate_from_tokens")
+    worker_from_prompt_endpoint = worker_component.endpoint("generate")
+    preprocess_endpoint = preprocess_component.endpoint("generate")
+
+    # TODO Hack until we unify lease_id and worker_id
+    VLLM_WORKER_ID = uuid.UUID(int=worker_from_tokens_endpoint.lease_id())
+    os.environ["VLLM_WORKER_ID"] = str(VLLM_WORKER_ID)
+    vllm_logger.info(f"Generate endpoint ID: {VLLM_WORKER_ID}")
+
+    vllm_engine = VllmEngine(engine_args, router_client)
+    vllm_engine = await vllm_engine.init()
+
+    await asyncio.gather(
+        worker_from_tokens_endpoint.serve_endpoint(vllm_engine.generate_from_tokens),
+        worker_from_prompt_endpoint.serve_endpoint(vllm_engine.generate_from_prompt),
+        preprocess_endpoint.serve_endpoint(vllm_engine.preprocess),
+    )
+
+
+if __name__ == "__main__":
+    uvloop.install()
+    engine_args = parse_vllm_args()
+    asyncio.run(worker(engine_args))

llm/rust/Cargo.lock

@@ -1637,6 +1637,12 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+
 [[package]]
 name = "futures-util"
 version = "0.3.31"
@@ -2472,7 +2478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if 1.0.0",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2491,6 +2497,27 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "libtriton-llm"
+version = "0.1.1"
+dependencies = [
+ "anyhow",
+ "async-once-cell",
+ "cbindgen",
+ "futures",
+ "libc",
+ "once_cell",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "tracing-subscriber",
+ "triton-distributed",
+ "triton-llm",
+ "uuid 1.13.1",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -3152,9 +3179,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.20.2"
+version = "1.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
 
 [[package]]
 name = "onig"
@@ -3909,6 +3936,12 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "reqwest"
 version = "0.12.12"
@@ -3976,6 +4009,35 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rstest"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97eeab2f3c0a199bc4be135c36c924b6590b88c377d416494288c14f2db30199"
+dependencies = [
+ "futures",
+ "futures-timer",
+ "rstest_macros",
+ "rustc_version",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d428f8247852f894ee1be110b375111b586d4fa431f6c46e64ba5a0dcccbe605"
+dependencies = [
+ "cfg-if 1.0.0",
+ "glob",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn 2.0.98",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -5233,6 +5295,7 @@ dependencies = [
  "proptest",
  "regex",
  "reqwest",
+ "rstest",
  "serde",
  "serde_json",
  "thiserror 2.0.11",
@@ -5244,6 +5307,7 @@ dependencies = [
  "unicode-segmentation",
  "uuid 1.13.1",
  "validator",
+ "xxhash-rust",
 ]
 
 [[package]]

llm/rust/Cargo.toml

@@ -16,6 +16,7 @@
 [workspace]
 members = [
     "triton-llm",
+    "libtriton-llm",
 ]
 resolver = "2"
 
@@ -47,3 +48,4 @@ tokio-util = { version = "0.7", features = ["codec", "net"] }
 tracing = { version = "0.1" }
 validator = { version = "0.20.0", features = ["derive"] }
 uuid = { version = "1", features = ["v4", "serde"] }
+xxhash-rust = { version = "0.8", features = ["xxh3", "const_xxh3"] }

llm/rust/libtriton-llm/Cargo.lock

+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+dependencies = [
+ "anstyle",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "async-nats"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76433c4de73442daedb3a59e991d94e85c14ebfc33db53dfcd347a21cd6ef4f8"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures",
+ "memchr",
+ "nkeys",
+ "nuid",
+ "once_cell",
+ "pin-project",
+ "portable-atomic",
+ "rand",
+ "regex",
+ "ring",
+ "rustls-native-certs 0.7.3",
+ "rustls-pemfile",
+ "rustls-webpki",
+ "serde",
+ "serde_json",
+ "serde_nanos",
+ "serde_repr",
+ "thiserror",
+ "time",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tokio-websockets",
+ "tracing",
+ "tryhard",
+ "url",
+]
+
+[[package]]
+name = "async-once-cell"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288f83726785267c6f2ef073a3d83dc3f9b81464e9f99898240cced85fce35a"
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "644dd749086bf3771a2fbc5f256fdb982d53f011c7d5d560304eafeecebce79d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "async_zmq"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "499c7104563d51146553fb0963f00210d8825833789e0ed270dd96aeeff6ac93"
+dependencies = [
+ "futures",
+ "mio 0.6.23",
+ "once_cell",
+ "slab",
+ "thiserror",
+ "zmq",
+]
+
+[[package]]
+name = "atomic"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d818003e740b63afc82337e3160717f4f63078720a810b7b903e70a5d1d2994"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "axum"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "sync_wrapper",
+ "tower 0.5.2",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.74"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
+dependencies = [
+ "addr2line",
+ "cfg-if 1.0.0",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-targets",
+]
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"
+
+[[package]]
+name = "blake3"
+version = "1.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if 1.0.0",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bytemuck"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cbindgen"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fce8dd7fcfcbf3a0a87d8f515194b49d6135acab73e18bd380d1d93bb1a15eb"
+dependencies = [
+ "clap",
+ "heck 0.4.1",
+ "indexmap 2.7.0",
+ "log",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "syn 2.0.96",
+ "tempfile",
+ "toml",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7777341816418c02e033934a09f20dc0ccaf65a5201ef8a450ae0105a573fda"
+dependencies = [
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "clap"
+version = "4.5.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8eb5e908ef3a6efbe1ed62520fb7287959888c88485abe072543190ecc66783"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b01801b5fc6a0a232407abc821660c9c6d25a1cafc0d4f85f29fb8d9afc121"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest",
+ "fiat-crypto",
+ "rustc_version",
+ "subtle",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+ "serde",
+]
+
+[[package]]
+name = "derive-getters"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74ef43543e701c01ad77d3a5922755c6a1d71b22d942cb8042be4994b380caff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dircpy"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a88521b0517f5f9d51d11925d8ab4523497dcf947073fa3231a311b63941131c"
+dependencies = [
+ "jwalk",
+ "log",
+ "walkdir",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "ed25519"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
+dependencies = [
+ "signature",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
+dependencies = [
+ "curve25519-dalek",
+ "ed25519",
+ "sha2",
+ "signature",
+ "subtle",
+]
+
+[[package]]
+name = "educe"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
+dependencies = [
+ "enum-ordinalize",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "enum-ordinalize"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "errno"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "etcd-client"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0452bcc559431b16f472b7ab86e2f9ccd5f3c2da3795afbd6b773665e047fe"
+dependencies = [
+ "http",
+ "prost",
+ "tokio",
+ "tokio-stream",
+ "tonic",
+ "tonic-build",
+ "tower 0.4.13",
+ "tower-service",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
+
+[[package]]
+name = "figment"
+version = "0.10.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
+dependencies = [
+ "atomic",
+ "parking_lot",
+ "pear",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "toml",
+ "uncased",
+ "version_check",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags 1.3.2",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets",
+]
+
+[[package]]
+name = "gimli"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+
+[[package]]
+name = "h2"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccae279728d634d083c00f6099cb58f01cc99c145b84b8be2f6c74618d79922e"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap 2.7.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "http"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f16ca2af56261c99fba8bac40a10251ce8188205a4c448fbb745a2e4daa76fea"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2d708df4e7140240a16cd6ab0ab65c972d7433ab77819ea693fde9c43811e2a"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "hyper"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-timeout"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
+dependencies = [
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.15.2",
+]
+
+[[package]]
+name = "inlinable_string"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+
+[[package]]
+name = "jobserver"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "jwalk"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2735847566356cd2179a2a38264839308f7079fa96e6bd5a42d740460e003c56"
+dependencies = [
+ "crossbeam",
+ "rayon",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.169"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+
+[[package]]
+name = "libtriton_llm"
+version = "0.1.1"
+dependencies = [
+ "anyhow",
+ "async-once-cell",
+ "cbindgen",
+ "futures",
+ "libc",
+ "once_cell",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "triton-distributed",
+ "uuid",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "litemap"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"
+
+[[package]]
+name = "local-ip-address"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3669cf5561f8d27e8fc84cc15e58350e70f557d4d65f70e3154e54cd2f8e1782"
+dependencies = [
+ "libc",
+ "neli",
+ "thiserror",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "mio"
+version = "0.6.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
+dependencies = [
+ "cfg-if 0.1.10",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log",
+ "miow",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+dependencies = [
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
+]
+
+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
+[[package]]
+name = "neli"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93062a0dce6da2517ea35f301dfc88184ce18d3601ec786a727a87bf535deca9"
+dependencies = [
+ "byteorder",
+ "libc",
+ "log",
+ "neli-proc-macros",
+]
+
+[[package]]
+name = "neli-proc-macros"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c8034b7fbb6f9455b2a96c19e6edf8dc9fc34c70449938d8ee3b4df363f61fe"
+dependencies = [
+ "either",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
+dependencies = [
+ "cfg-if 0.1.10",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "nid"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4abdf1789932b85dc39446e27f45a1064a30f9e19a2b872b1d09bd59283f85f3"
+dependencies = [
+ "rand",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.7.0",
+ "cfg-if 1.0.0",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "nkeys"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f49e787f4c61cbd0f9320b31cc26e58719f6aa5068e34697dd3aea361412fe3"
+dependencies = [
+ "data-encoding",
+ "ed25519",
+ "ed25519-dalek",
+ "getrandom 0.2.15",
+ "log",
+ "rand",
+ "signatory",
+]
+
+[[package]]
+name = "nuid"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc895af95856f929163a0aa20c26a78d26bfdc839f51b9d5aa7a5b79e52b7e83"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "object"
+version = "0.36.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets",
+]
+
+[[package]]
+name = "pear"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467"
+dependencies = [
+ "inlinable_string",
+ "pear_codegen",
+ "yansi",
+]
+
+[[package]]
+name = "pear_codegen"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147"
+dependencies = [
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.7.0",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfe2e71e1471fe07709406bf725f710b02927c9c54b2b5b2ec0e8087d97c327d"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e859e6e5bd50440ab63c47e3ebabc90f26251f7c73c3d3e837b74a1cc3fa67"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
+
+[[package]]
+name = "portable-atomic"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6924ced06e1f7dfe3fa48d57b9f74f55d8915f5036121bef647ef4b204895fac"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proc-macro2-diagnostics"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+ "version_check",
+ "yansi",
+]
+
+[[package]]
+name = "prometheus"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d33c28a30771f7f96db69893f78b857f7450d7e0237e9c8fc6427a81bae7ed1"
+dependencies = [
+ "cfg-if 1.0.0",
+ "fnv",
+ "lazy_static",
+ "memchr",
+ "parking_lot",
+ "protobuf",
+ "thiserror",
+]
+
+[[package]]
+name = "prost"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c0fef6c4230e4ccf618a35c59d7ede15dea37de8427500f50aff708806e42ec"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0f3e5beed80eb580c68e2c600937ac2c4eedabdfd5ef1e5b7ea4f3fba84497b"
+dependencies = [
+ "heck 0.4.1",
+ "itertools",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 2.0.96",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "157c5a9d7ea5c2ed2d9fb8f495b64759f7816c7eaea54ba3978f0d63000162e3"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc2f1e56baa61e93533aebc21af4d2134b70f66275e0fcdf3cbe43d77ff7e8fc"
+dependencies = [
+ "prost",
+]
+
+[[package]]
+name = "protobuf"
+version = "2.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.15",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
+dependencies = [
+ "bitflags 2.7.0",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "ring"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+dependencies = [
+ "cc",
+ "cfg-if 1.0.0",
+ "getrandom 0.2.15",
+ "libc",
+ "spin",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
+dependencies = [
+ "bitflags 2.7.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb9263ab4eb695e42321db096e3b8fbd715a59b154d5c88d82db2175b681ba7"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.2.0",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "917ce264624a4b4db1c364dcc35bfca9ded014d0a958cd47ad3e960e988ea51c"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.7.0",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
+dependencies = [
+ "bitflags 2.7.0",
+ "core-foundation 0.10.0",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
+
+[[package]]
+name = "serde"
+version = "1.0.217"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.217"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.138"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_nanos"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a93142f0367a4cc53ae0fead1bcda39e85beccfad3dcd717656cacab94b12985"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "signatory"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1e303f8205714074f6068773f0e29527e0453937fe837c9717d066635b65f31"
+dependencies = [
+ "pkcs8",
+ "rand_core",
+ "signature",
+ "zeroize",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "socket2"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+
+[[package]]
+name = "synstructure"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml",
+ "version-compare",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tempfile"
+version = "3.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8a559c81686f576e8cd0290cd2a24a2a9ad80c98b3478856500fcbd7acd704"
+dependencies = [
+ "cfg-if 1.0.0",
+ "fastrand",
+ "getrandom 0.2.15",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "time"
+version = "0.3.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35e7868883861bd0e56d9ac6efcaaca0d6d5d82a2a7ec8209ff492c07cf37b21"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2834e6017e3e5e4b9834939793b282bc03b37a3336245fa820e35e233e2a85de"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.43.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "libc",
+ "mio 1.0.3",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6d0975eaace0cf0fcadee4e4aaa5da15b5c079146f2cffb67c113be122bf37"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-websockets"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f591660438b3038dd04d16c938271c79e7e06260ad2ea2885a4861bfb238605d"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "httparse",
+ "rand",
+ "ring",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
+dependencies = [
+ "indexmap 2.7.0",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "tonic"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52"
+dependencies = [
+ "async-stream",
+ "async-trait",
+ "axum",
+ "base64",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
+ "pin-project",
+ "prost",
+ "socket2",
+ "tokio",
+ "tokio-stream",
+ "tower 0.4.13",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tonic-build"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9557ce109ea773b399c9b9e5dca39294110b74f1f342cb347a80d1fce8c26a11"
+dependencies = [
+ "prettyplease",
+ "proc-macro2",
+ "prost-build",
+ "prost-types",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "indexmap 1.9.3",
+ "pin-project",
+ "pin-project-lite",
+ "rand",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "triton-distributed"
+version = "0.2.0"
+dependencies = [
+ "anyhow",
+ "async-nats",
+ "async-once-cell",
+ "async-stream",
+ "async-trait",
+ "async_zmq",
+ "blake3",
+ "bytes",
+ "derive-getters",
+ "derive_builder",
+ "educe",
+ "either",
+ "etcd-client",
+ "figment",
+ "futures",
+ "humantime",
+ "local-ip-address",
+ "nid",
+ "nix",
+ "nuid",
+ "once_cell",
+ "prometheus",
+ "rand",
+ "regex",
+ "serde",
+ "serde_json",
+ "socket2",
+ "thiserror",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tracing",
+ "uuid",
+ "validator",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tryhard"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9f0a709784e86923586cff0d872dba54cd2d2e116b3bc57587d15737cfce9d"
+dependencies = [
+ "futures",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "uncased"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+]
+
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced87ca4be083373936a67f8de945faa23b6b42384bd5b64434850802c6dccd0"
+dependencies = [
+ "getrandom 0.3.1",
+ "serde",
+]
+
+[[package]]
+name = "validator"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43fb22e1a008ece370ce08a3e9e4447a910e92621bb49b85d6e48a45397e7cfa"
+dependencies = [
+ "idna",
+ "once_cell",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "url",
+ "validator_derive",
+]
+
+[[package]]
+name = "validator_derive"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7df16e474ef958526d1205f6dda359fdfab79d9aa6d54bafcb92dcd07673dca"
+dependencies = [
+ "darling",
+ "once_cell",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "version-compare"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "0.6.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+dependencies = [
+ "bitflags 2.7.0",
+]
+
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "xxhash-rust"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
+[[package]]
+name = "yoke"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+
+[[package]]
+name = "zeromq-src"
+version = "0.2.6+4.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc120b771270365d5ed0dfb4baf1005f2243ae1ae83703265cb3504070f4160b"
+dependencies = [
+ "cc",
+ "dircpy",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
+
+[[package]]
+name = "zmq"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd3091dd571fb84a9b3e5e5c6a807d186c411c812c8618786c3c30e5349234e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+ "zmq-sys",
+]
+
+[[package]]
+name = "zmq-sys"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8351dc72494b4d7f5652a681c33634063bbad58046c1689e75270908fdc864"
+dependencies = [
+ "libc",
+ "system-deps",
+ "zeromq-src",
+]

llm/rust/libtriton-llm/Cargo.toml

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[package]
+name = "libtriton-llm"
+version = "0.1.1"
+edition = "2021"
+authors = ["NVIDIA"]
+license = "Apache-2.0"
+homepage = "https://github.com/triton-inference-server/triton_distributed"
+repository = "https://github.com/triton-inference-server/triton_distributed"
+
+[lib]
+name = "triton_llm_capi"
+crate-type = ["cdylib"]
+
+[build-dependencies]
+cbindgen = "0.27"
+
+[dependencies]
+triton-llm = { path = "../triton-llm" }
+triton-distributed = { workspace = true }
+
+anyhow = { version = "1" }
+futures = "0.3"
+once_cell = "1"
+serde = "1"
+serde_json = "1.0.138"
+tokio = { version = "1", features = ["full"] }
+tokio-stream = "0"
+tracing = "0"
+libc = "0.2"
+uuid = { version = "1", features = ["v4", "serde"] }
+async-once-cell = "0.5.4"
+tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
\ No newline at end of file

llm/rust/libtriton-llm/build.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::env;
+use std::path::Path;
+
+fn main() {
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+
+    let header_path = Path::new(&crate_dir)
+        .join("include")
+        .join("nvidia")
+        .join("triton_llm")
+        .join("llm_engine.h");
+
+    cbindgen::generate(crate_dir)
+        .expect("Unable to generate bindings")
+        .write_to_file(header_path);
+}

llm/rust/libtriton-llm/cbindgen.toml

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+language = "C++"
+cpp_compat = true
+include_guard = "__NVIDIA_TRITON_LLM_API__"
+
+
+[enum]
+rename_variants = "none"
+prefix_with_name = false
+enum_class = false
+
+
+[export]
+include = ["TritonLlmResult", "triton_llm_init", "triton_llm_shutdown"]
+
+[export.rename]
+"TritonLlmResult" = "triton_llm_result_t"

llm/rust/libtriton-llm/src/lib.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use async_once_cell::OnceCell as AsyncOnceCell;
+use libc::c_char;
+use once_cell::sync::OnceCell;
+use std::ffi::CStr;
+use uuid::Uuid;
+use std::sync::atomic::{AtomicU32, Ordering};
+use tracing as log;
+
+use triton_distributed::{DistributedRuntime, Worker};
+use triton_llm::kv_router::{
+    indexer::compute_block_hash_for_seq, protocols::*, publisher::KvPublisher,
+};
+static WK: OnceCell<Worker> = OnceCell::new();
+static DRT: AsyncOnceCell<DistributedRuntime> = AsyncOnceCell::new();
+// [FIXME] shouldn't the publisher be instance passing between API calls?
+static KV_PUB: OnceCell<KvPublisher> = OnceCell::new();
+
+fn initialize_tracing() {
+    // Sets up RUST_LOG environment variable for logging while KV Publishing
+    // Example: os.environ["RUST_LOG"] = "debug"
+    let subscriber = tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("setting default subscriber failed");
+
+    log::debug!("Tracing initialized");
+}
+
+#[repr(u32)]
+pub enum TritonLlmResult {
+    OK = 0,
+    ERR = 1,
+}
+
+/// # Safety
+/// the model_name_c_str and worker_id_c_str are passed as pointers to C strings
+#[no_mangle]
+pub unsafe extern "C" fn triton_llm_init(
+    model_name_c_str: *const c_char,
+    worker_id_c_str: *const c_char,
+) -> TritonLlmResult {
+    initialize_tracing();
+    let wk = match WK.get_or_try_init(Worker::from_settings) {
+        Ok(wk) => wk.clone(),
+        Err(e) => {
+            eprintln!("Failed to initialize runtime: {:?}", e);
+            return TritonLlmResult::ERR;
+        }
+    };
+    let rt = wk.runtime();
+    let secondary = rt.secondary().clone();
+    let result = secondary.block_on(async {
+        // Initialize the distributed runtime
+        match DRT
+            .get_or_try_init(async { DistributedRuntime::from_settings(rt.clone()).await })
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                eprintln!("Failed to initialize distributed runtime: {:?}", e);
+                Err(TritonLlmResult::ERR)
+            }
+        }
+    });
+    let model_name = match unsafe { CStr::from_ptr(model_name_c_str) }.to_str() {
+        Ok(s) => s.to_string(),
+        Err(e) => {
+            eprintln!("Failed to convert C string to Rust string: {:?}", e);
+            return TritonLlmResult::ERR;
+        }
+    };
+
+    let worker_id_str = match unsafe { CStr::from_ptr(worker_id_c_str) }.to_str() {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Failed to convert C string to Rust string: {:?}", e);
+            return TritonLlmResult::ERR;
+        }
+    };
+
+    let worker_id_uuid = match Uuid::parse_str(worker_id_str) {
+        Ok(uuid) => uuid,
+        Err(e) => {
+            eprintln!("Failed to parse worker_id as UUID: {:?}", e);
+            return TritonLlmResult::ERR;
+        }
+    };
+    match result {
+        Ok(_) => match KV_PUB
+            .get_or_try_init(move || triton_create_kv_publisher(model_name, worker_id_uuid))
+        {
+            Ok(_) => TritonLlmResult::OK,
+            Err(e) => {
+                eprintln!("Failed to initialize distributed runtime: {:?}", e);
+                TritonLlmResult::ERR
+            }
+        },
+        Err(e) => e,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn triton_llm_shutdown() -> TritonLlmResult {
+    let wk = match WK.get() {
+        Some(wk) => wk,
+        None => {
+            eprintln!("Runtime not initialized");
+            return TritonLlmResult::ERR;
+        }
+    };
+
+    wk.runtime().shutdown();
+
+    TritonLlmResult::OK
+}
+
+#[no_mangle]
+pub extern "C" fn triton_llm_load_publisher_create() -> TritonLlmResult {
+    TritonLlmResult::OK
+}
+
+// instantiate a kv publisher
+// this will bring up the task to publish and the channels to await publishing events
+// the [`triton_kv_publish_store_event`] call will use a handle to the publisher to send events
+// store and the [`triton_kv_event_create_removed`] will create remove events
+// these call mus be driving by external c++ threads that are consuming the kv events from the
+// c++ executor api
+
+fn triton_create_kv_publisher(
+    model_name: String,
+    worker_id: Uuid,
+) -> Result<KvPublisher, anyhow::Error> {
+    log::info!("Creating KV Publisher for model: {}", model_name);
+    match DRT
+        .get()
+        .ok_or(anyhow::Error::msg("Could not get Distributed Runtime"))
+    {
+        Ok(drt) => {
+            let backend = drt.namespace("router")?.component(model_name)?;
+            KvPublisher::new(drt.clone(), backend, worker_id)
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn kv_event_create_stored_block_from_parts(
+    block_hash: u64,
+    token_ids: *const u32,
+    num_tokens: usize,
+    _lora_id: u64,
+) -> KvCacheStoredBlockData {
+    let tokens_hash =
+        compute_block_hash_for_seq(unsafe { std::slice::from_raw_parts(token_ids, num_tokens) })[0];
+    KvCacheStoredBlockData {
+        block_hash: ExternalSequenceBlockHash(block_hash),
+        tokens_hash,
+    }
+}
+static WARN_COUNT: AtomicU32 = AtomicU32::new(0);
+
+fn kv_event_create_stored_from_parts(
+    event_id: u64,
+    token_ids: *const u32,
+    num_block_tokens: *const usize,
+    block_ids: *const u64,
+    num_blocks: usize,
+    parent_hash: Option<u64>,
+    lora_id: u64,
+) -> KvCacheEvent {
+    let mut blocks: Vec<KvCacheStoredBlockData> = Vec::new();
+
+    let mut token_offset: usize = 0;
+    for block_idx in 0..num_blocks {
+        let block_hash = unsafe { *block_ids.offset(block_idx.try_into().unwrap()) };
+        let tokens = unsafe { token_ids.offset(token_offset.try_into().unwrap()) };
+        let num_toks = unsafe { *num_block_tokens.offset(block_idx.try_into().unwrap()) };
+        // compute hash only apply to full block (KV_BLOCK_SIZE token)
+        if num_toks != 64 {
+            if WARN_COUNT.fetch_update(
+                Ordering::SeqCst,
+                Ordering::SeqCst,
+                |c| if c < 3 { Some(c + 1) } else { None }).is_ok() {
+                log::warn!("Block size must be 64 tokens to be published. Block size is: {}", num_toks);
+            }
+            break;
+        }
+        token_offset += num_toks;
+        blocks.push(kv_event_create_stored_block_from_parts(
+            block_hash, tokens, num_toks, lora_id,
+        ));
+    }
+
+    KvCacheEvent {
+        data: KvCacheEventData::Stored(KvCacheStoreData {
+            blocks,
+            parent_hash: parent_hash.map(ExternalSequenceBlockHash),
+        }),
+        event_id,
+    }
+}
+
+fn kv_event_create_removed_from_parts(
+    event_id: u64,
+    block_ids: *const u64,
+    num_blocks: usize,
+) -> KvCacheEvent {
+    let block_hashes: Vec<ExternalSequenceBlockHash> =
+        unsafe { std::slice::from_raw_parts(block_ids, num_blocks) }
+            .to_vec()
+            .iter()
+            .map(|&v| ExternalSequenceBlockHash(v))
+            .collect();
+    KvCacheEvent {
+        event_id,
+        data: KvCacheEventData::Removed(KvCacheRemoveData { block_hashes }),
+    }
+}
+
+/// # Safety
+/// parent_hash is passed as pointer to indicate whether the blocks
+/// has a parent hash or not. nullptr is used to represent no parent hash
+#[no_mangle]
+pub unsafe extern "C" fn triton_kv_event_publish_stored(
+    event_id: u64,
+    token_ids: *const u32,
+    num_block_tokens: *const usize,
+    block_ids: *const u64,
+    num_blocks: usize,
+    parent_hash: *const u64,
+    lora_id: u64,
+) -> TritonLlmResult {
+    let publisher = KV_PUB.get().unwrap();
+    let parent_hash = {
+        if parent_hash.is_null() {
+            None
+        } else {
+            Some(unsafe { *parent_hash })
+        }
+    };
+    let event = kv_event_create_stored_from_parts(
+        event_id,
+        token_ids,
+        num_block_tokens,
+        block_ids,
+        num_blocks,
+        parent_hash,
+        lora_id,
+    );
+    match publisher.publish(event) {
+        Ok(_) => TritonLlmResult::OK,
+        Err(e) => {
+            eprintln!("Error publishing stored kv event {:?}", e);
+            TritonLlmResult::ERR
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn triton_kv_event_publish_removed(
+    event_id: u64,
+    block_ids: *const u64,
+    num_blocks: usize,
+) -> TritonLlmResult {
+    let publisher = KV_PUB.get().unwrap();
+    let event = kv_event_create_removed_from_parts(event_id, block_ids, num_blocks);
+    match publisher.publish(event) {
+        Ok(_) => TritonLlmResult::OK,
+        Err(e) => {
+            eprintln!("Error publishing removed kv event {:?}", e);
+            TritonLlmResult::ERR
+        }
+    }
+}
+
+// #[no_mangle]
+// pub extern "C" fn triton_kv_publish_store_event(
+//     event_id: u64,
+//     token_ids: *const u32,
+//     num_tokens: usize,
+//     lora_id: u64,
+// ) -> TritonLlmResult {
+//     // if event.is_null() || token_ids.is_null() {
+//     //     return tritonKvErrorType::INVALID_TOKEN_IDS;
+//     // }
+
+//     // let tokens = unsafe { std::slice::from_raw_parts(token_ids, num_tokens) }.to_vec();
+//     // let new_event = Box::new(KvCacheStoreData {
+//     //     event_id,
+//     //     lora_id,
+//     //     token_ids: tokens,
+//     //     block_hashes: Vec::new(),
+//     // });
+
+//     // unsafe { *event = Box::into_raw(new_event) };
+
+//     TritonLlmResult::OK
+// }
+
+// #[no_mangle]
+// pub extern "C" fn triton_kv_event_create_removed(
+//     event_id: u64,
+//     block_hashes: *const u64,
+//     num_hashes: usize,
+// ) -> TritonLlmResult {
+//     // if event.is_null() || block_hashes.is_null() {
+//     //     return -1;
+//     // }
+
+//     // let hashes = unsafe { std::slice::from_raw_parts(block_hashes, num_hashes) }.to_vec();
+//     // let new_event = Box::new(KvCacheRemoveData {
+//     //     event_id,
+//     //     lora_id: 0,
+//     //     token_ids: Vec::new(),
+//     //     block_hashes: hashes,
+//     // });
+
+//     // unsafe { *event = Box::into_raw(new_event) };
+//     // 0
+//     TritonLlmResult::OK
+// }
+
+// /// create load publisher object and return a handle
+// /// load publisher will instantiate the nats service and tie its stats handler to
+// /// a watch channel receiver.  the watch channel sender will be attach to the
+// /// handle and calls to [`triton_load_stats_publish`] issue the stats to the watch t
+// pub extern "C" fn triton_load_publisher_create() -> *mut LoadPublisher {
+//     // let publisher = Box::new(LoadPublisher::new());
+//     // Box::into_raw(publisher)
+// }
+
+// pub extern "C" fn triton_load_stats_publish(
+//     publisher: *mut LoadPublisher,
+//     active_slots: u64,
+//     total_slots: u64,
+//     active_kv: u64,
+//     total_kv: u64,
+// ) {
+//     // let publisher = unsafe { &mut *publisher };
+// }

llm/rust/triton-llm/Cargo.toml

@@ -46,6 +46,7 @@ tokio-util = { workspace = true }
 tracing = { workspace = true }
 validator = { workspace = true }
 uuid = { workspace = true }
+xxhash-rust = { workspace = true }
 
 # protocols
 chrono = { version = "0.4" }
@@ -66,3 +67,4 @@ mistralrs = { git = "https://github.com/EricLBuehler/mistral.rs.git", rev = "5e6
 insta = { version = "1.41", features = ["glob", "json", "redactions"]}
 proptest = "1.5.0"
 reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+rstest = "0.18.2"
\ No newline at end of file

llm/rust/triton-llm/src/kv_router.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use anyhow::Result;
+use futures::stream::StreamExt;
+use std::{sync::Arc, time::Duration};
+use tokio_util::sync::CancellationToken;
+use tracing as log;
+use triton_distributed::{component::Component, DistributedRuntime};
+
+pub mod indexer;
+pub mod protocols;
+pub mod publisher;
+// [WIP] enable service_builder() through worker for metrics reporting
+// pub mod worker;
+mod scheduler;
+mod scoring;
+
+use crate::kv_router::{
+    indexer::{KvIndexer, KvIndexerInterface, RouterEvent},
+    protocols::KV_BLOCK_SIZE,
+    scheduler::{Endpoint, KvScheduler, Service},
+    scoring::ProcessedEndpoints,
+};
+
+// this should be discovered from the backend
+pub const KV_EVENT_SUBJECT: &str = "kv_events";
+
+pub struct KvRouter {
+    // properties of request plane
+    // maybe rolled up into the generic object or not
+    service_name: String,
+
+    cancellation_token: CancellationToken,
+
+    scheduler: KvScheduler,
+
+    indexer: KvIndexer,
+}
+
+impl KvRouter {
+    pub async fn from_runtime(
+        runtime: DistributedRuntime,
+        backend: Component,
+    ) -> Result<Arc<Self>> {
+        let nats_client = runtime.nats_client();
+        let service_name = backend.service_name();
+        let kv_subject = backend.event_subject(KV_EVENT_SUBJECT);
+        log::info!("Component Service Name {}", service_name);
+        log::info!("KV Subject {}", kv_subject);
+        Self::new(nats_client, service_name, kv_subject).await
+    }
+
+    pub async fn new(
+        nats_client: triton_distributed::transports::nats::Client,
+        service_name: String,
+        kv_subject: String,
+    ) -> Result<Arc<Self>> {
+        let cancellation_token = CancellationToken::new();
+        let (ep_tx, ep_rx) = tokio::sync::mpsc::channel(128);
+
+        tokio::spawn(collect_endpoints(
+            nats_client.clone(),
+            service_name.clone(),
+            ep_tx,
+            cancellation_token.clone(),
+        ));
+
+        let indexer = KvIndexer::new(cancellation_token.clone());
+        let scheduler = KvScheduler::start(ep_rx).await?;
+
+        log::debug!("subscribing to kv events: {}", kv_subject);
+        let mut kv_events_rx = nats_client.client().subscribe(kv_subject).await?;
+        let kv_events_tx = indexer.event_sender();
+
+        tokio::spawn(async move {
+            while let Some(event) = kv_events_rx.next().await {
+                let event: RouterEvent = serde_json::from_slice(&event.payload).unwrap();
+                log::debug!("received kv event: {:?}", event);
+                if let Err(e) = kv_events_tx.send(event).await {
+                    log::trace!("failed to send kv event to indexer; shutting down: {:?}", e);
+                }
+            }
+        });
+
+        Ok(Arc::new(Self {
+            service_name,
+            cancellation_token,
+            scheduler,
+            indexer,
+        }))
+    }
+
+    pub fn cancellation_token(&self) -> CancellationToken {
+        self.cancellation_token.clone()
+    }
+
+    pub fn service_name(&self) -> &str {
+        &self.service_name
+    }
+
+    // [TODO] indexer needs to take 'lora_id' as parameter
+    pub async fn schedule(&self, token_ids: &Vec<u32>, _lora_id: u64) -> Result<String> {
+        // Extracting part of the code in KvRouter::generate() for only
+        // the decision making part, routing is done by the caller
+        let isl_tokens = token_ids.len();
+        let overlap_scores = self
+            .indexer
+            .find_matches_for_request(token_ids.as_slice())
+            .await?;
+        log::debug!("KV router overlap_scores: {:?}", overlap_scores);
+        // [FIXME] Python binding results in "endpoint subscriber shutdown" error,
+        // need to investigate whether it happens in pure rust as well and then
+        // root cause it. Before that, not doing intelligent scheduling for rapid
+        // development..
+        // [FIXME] also need to fix that scheduler returns worker subject which is not
+        // the same as worker id (uuid). Seems like it adds additional annotation on top of uuid.
+        // Need to double check
+        // 'worker_subject' should be the same as worker id used for direct routing
+        // let worker_subject = self.scheduler.schedule(overlap_scores, isl_tokens).await?;
+        let mut selected_worker_subject = Option::<String>::None;
+        for (worker_subject, overlap_score) in &overlap_scores.scores {
+            if ((*overlap_score as usize * KV_BLOCK_SIZE) as f64 / isl_tokens as f64) >= 0.5 {
+                selected_worker_subject = Some(worker_subject.to_string());
+            }
+        }
+        match selected_worker_subject {
+            None => Err(anyhow::anyhow!("No worker found")),
+            Some(worker_subject) => Ok(worker_subject),
+        }
+    }
+}
+
+async fn collect_endpoints(
+    nats_client: triton_distributed::transports::nats::Client,
+    service_name: String,
+    ep_tx: tokio::sync::mpsc::Sender<ProcessedEndpoints>,
+    cancel: CancellationToken,
+) {
+    loop {
+        tokio::select! {
+            _ = cancel.cancelled() => {
+                log::debug!("cancellation token triggered");
+                break;
+            }
+            _ = tokio::time::sleep(Duration::from_secs(1)) => {
+                log::trace!("collecting endpoints for service: {}", service_name);
+            }
+        }
+
+        let values = nats_client
+            .get_endpoints(&service_name, Duration::from_secs(1))
+            .await
+            .unwrap();
+
+        // [FIXME] Endpoint is parsed from nats stats handler which may not include 'data' field
+        // if the service hasn't registered the handler.
+        // Another option is to make sure the router is configured properly that
+        // it listens to the right subject (where other publisher has stats).
+        let services: Vec<Service> = values
+            .into_iter()
+            .filter(|v| !v.is_empty())
+            .map(|v| {
+                let value: serde_json::Value = serde_json::from_slice(&v).unwrap();
+                log::trace!("service value: {:?}", value);
+                serde_json::from_slice(&v).unwrap()
+            })
+            .collect();
+
+        let endpoints: Vec<Endpoint> = services.into_iter().flat_map(|s| s.endpoints).collect();
+
+        log::trace!(
+            "found {} endpoints for service: {}",
+            endpoints.len(),
+            service_name
+        );
+
+        let processed = ProcessedEndpoints::new(endpoints);
+
+        // process endpoints into
+        if ep_tx.send(processed).await.is_err() {
+            log::trace!("failed to send processed endpoints; shutting down");
+            break;
+        }
+    }
+}

llm/rust/triton-llm/src/kv_router/indexer.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! KV RadixTree
+//!
+//! This module implements a key-value (KV) store using a Radix Tree structure to efficiently manage and retrieve data blocks.
+//! It is designed to support LLM (Large Language Model) inference by re-using a global KV cache.
+//!
+//! # Overview
+//!
+//! The main components of this module include:
+//!
+//! - **Radix Tree Structure**:
+//!   - The `RadixTree` struct represents the main data structure, with nodes (`RadixBlock`) containing children and associated worker IDs.
+//!   - It allows efficient storage and retrieval of data blocks based on their hashes.
+//!
+//! - **Event Handling**:
+//!   - The `RouterEvent` struct represents events emitted by LLM workers, which can be applied to the Radix Tree to update its state.
+//!   - The `KvIndexer` struct manages these events and match requests asynchronously using Tokio channels.
+//!
+//! - **Hash Computation**:
+//!   - Functions like `compute_block_hash` and `compute_block_hash_for_seq` compute hashes for data blocks and sequences of tokens, facilitating quick lookups.
+//!
+//! - **Concurrency and Asynchronous Operations**:
+//!   - The `KvIndexer` uses a single-threaded Tokio runtime to handle events and match requests concurrently, ensuring efficient processing without blocking.
+//!
+//! - **Match Requests**:
+//!   - The `MatchRequest` struct represents requests to find matches in the Radix Tree, returning overlap scores indicating the best matches.
+//!
+//! # Purpose
+//!
+//! This module provides a scalable and efficient way to manage and retrieve data blocks for LLM inference, leveraging a global KV cache to optimize performance.
+
+use bytes::Bytes;
+// use prometheus::{IntCounter, IntGauge};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::{
+    cell::RefCell,
+    collections::{HashMap, HashSet, VecDeque},
+    iter,
+    rc::Rc,
+    sync::OnceLock,
+    thread::JoinHandle,
+    time::{Duration, Instant},
+};
+use tokio::sync::{broadcast, mpsc, oneshot};
+use tokio_util::sync::CancellationToken;
+use tracing as log;
+use xxhash_rust::xxh3;
+
+pub const XXH3_SEED: u64 = 1337;
+
+use crate::kv_router::protocols::*;
+
+/// Errors that can occur in the KV Router.
+#[derive(Debug, thiserror::Error)]
+pub enum KvRouterError {
+    #[error("Block not found")]
+    BlockNotFound,
+
+    #[error("Indexer is offline")]
+    IndexerOffline,
+
+    #[error("Indexer is dropped request")]
+    IndexerDroppedRequest,
+}
+
+/// Identifier of a LLM worker which emits events to the router.
+pub type WorkerId = uuid::Uuid;
+
+/// A shared reference to a [`RadixBlock`].
+type SharedRadixBlock = Rc<RefCell<RadixBlock>>;
+
+/// Compute the hash of a local block.
+///
+/// ### Arguments
+///
+/// * `data` - A byte slice representing the data to hash.
+///
+/// ### Returns
+///
+/// A `LocalBlockHash` representing the computed hash.
+pub fn compute_block_hash(data: &[u8]) -> LocalBlockHash {
+    LocalBlockHash(xxh3::xxh3_64_with_seed(data, XXH3_SEED))
+}
+
+// /// Updated version of the `compute_block_hash` function that included the lora_id
+// pub fn compute_block_hash_v2(token_id: &[u32], lora_id: u64) {
+//     let mut bytes = Vec::new();
+//     for token in token_id {
+//         bytes.extend_from_slice(&token.to_le_bytes());
+//     }
+//     bytes.extend_from_slice(&lora_id.to_le_bytes());
+//     let hash = xxh3::xxh3_64_with_seed(&bytes, XXH3_SEED);
+// }
+
+/// Compute the hash for a sequence of tokens.
+///
+/// ### Arguments
+///
+/// * `tokens` - A vector of `u32` tokens.
+///
+/// ### Returns
+///
+/// A vector of `LocalBlockHash` representing the computed hashes for each chunk of tokens.
+pub fn compute_block_hash_for_seq(tokens: &[u32]) -> Vec<LocalBlockHash> {
+    tokens
+        .chunks_exact(KV_BLOCK_SIZE) // Split into chunks of KV_BLOCK_SIZE elements
+        .map(|chunk| {
+            let bytes: Vec<u8> = chunk
+                .iter()
+                .flat_map(|&num| num.to_le_bytes()) // Convert each i32 to its little-endian bytes
+                .collect();
+
+            compute_block_hash(&Bytes::from(bytes)) // Convert the byte Vec to Bytes
+        })
+        .collect()
+}
+
+/// A [`KvCacheEvent`] on a specific LLM worker denoted by [`WorkerId`].
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RouterEvent {
+    /// The ID of the worker emitting the event.
+    worker_id: WorkerId,
+    /// The cache event associated with the worker.
+    event: KvCacheEvent,
+}
+
+impl RouterEvent {
+    /// Create a new `RouterEvent`.
+    ///
+    /// ### Arguments
+    ///
+    /// * `worker_id` - The ID of the worker emitting the event.
+    /// * `event` - The cache event.
+    ///
+    /// ### Returns
+    ///
+    /// A new `RouterEvent`.
+    pub fn new(worker_id: WorkerId, event: KvCacheEvent) -> Self {
+        Self { worker_id, event }
+    }
+}
+
+/// A block in the Radix Tree.
+struct RadixBlock {
+    /// A map of child blocks, keyed by their local block hash.
+    children: HashMap<LocalBlockHash, SharedRadixBlock>,
+    /// A set of worker IDs associated with this block.
+    workers: HashSet<WorkerId>,
+    /// A buffer of times that this block was last traversed
+    recent_uses: VecDeque<Instant>,
+}
+
+impl RadixBlock {
+    /// Create a new `RadixBlock`.
+    ///
+    /// ### Returns
+    ///
+    /// A new `RadixBlock`.
+    pub fn new() -> Self {
+        Self {
+            children: HashMap::new(),
+            workers: HashSet::new(),
+            recent_uses: VecDeque::new(),
+        }
+    }
+}
+
+pub struct RadixTree {
+    /// This is the root of the radix/prefix tree
+    /// This will only contain root blocks
+    root: SharedRadixBlock,
+
+    /// This is a global lookup table for all blocks which will let you jump into
+    /// the radix tree at any point
+    /// Lookup is best case O(1) and worst case O(N); however, even constant in-time
+    /// could be expensive if N is large
+    /// We should monitor the size of this table and consider using a proper radix tree.
+    /// Transitioning to a radix tree only would require a change in the messaging structure
+    /// as the entire prefix would need to be sent. Alternatively, we could use block_depth
+    /// integers to indicate how many blocks to skip and use a radix/prefix tree at each level.
+    lookup: HashMap<WorkerId, HashMap<ExternalSequenceBlockHash, SharedRadixBlock>>,
+    /// The time buffer the radix tree should check when considering frequence of block accesses
+    expiration_duration: Option<Duration>,
+}
+
+impl Default for RadixTree {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RadixTree {
+    /// Create a new `RadixTree`.
+    ///
+    /// ### Returns
+    ///
+    /// A new `RadixTree`.
+    pub fn new_with_frequency(expiration_duration: Option<Duration>) -> Self {
+        Self {
+            root: Rc::new(RefCell::new(RadixBlock::new())),
+            lookup: HashMap::new(),
+            expiration_duration,
+        }
+    }
+
+    pub fn new() -> Self {
+        Self::new_with_frequency(None)
+    }
+
+    /// Traverse the radix tree to find the best match for a given sequence of [`LocalBlockHash`]es.
+    ///
+    /// ### Arguments
+    ///
+    /// * `sequence` - A vector of `LocalBlockHash` representing the sequence to match.
+    /// * `early_exit` - A boolean indicating whether to exit early if a single match is found.
+    ///
+    /// ### Returns
+    ///
+    /// An `OverlapScores` representing the match scores.
+    pub fn find_matches(&self, sequence: Vec<LocalBlockHash>, early_exit: bool) -> OverlapScores {
+        let mut scores = OverlapScores::new();
+        let mut current = self.root.clone();
+        let now = Instant::now();
+        for block_hash in sequence {
+            let next_block = {
+                let current_borrow = current.borrow();
+                current_borrow.children.get(&block_hash).cloned()
+            };
+
+            if let Some(block) = next_block {
+                scores.update_scores(&block.borrow().workers);
+
+                if let Some(expiration_duration) = self.expiration_duration {
+                    let mut block_mut = block.borrow_mut();
+
+                    while let Some(access_time) = block_mut.recent_uses.front() {
+                        if now.duration_since(*access_time) > expiration_duration {
+                            block_mut.recent_uses.pop_front();
+                        } else {
+                            break;
+                        }
+                    }
+                    scores.add_frequency(block_mut.recent_uses.len());
+                    block_mut.recent_uses.push_back(now);
+                }
+
+                if early_exit && block.borrow().workers.len() == 1 {
+                    break;
+                }
+
+                current = block;
+            } else {
+                break;
+            }
+        }
+
+        scores
+    }
+
+    /// Apply a [`RouterEvent`] to the radix tree.
+    ///
+    /// ### Arguments
+    ///
+    /// * `event` - The `RouterEvent` to apply.
+    pub fn apply_event(&mut self, event: RouterEvent) {
+        let (worker_id, event) = (event.worker_id, event.event);
+        let (id, op) = (event.event_id, event.data);
+        log::debug!(id, "Store operation: {:?}", op);
+
+        let worker_lookup = self.lookup.entry(worker_id).or_default();
+
+        match op {
+            KvCacheEventData::Stored(op) => {
+                // find the parent block - if the parent exists it must be on our worker, if not,
+                // we check the radix tree's root to find it.
+                // this is the single most expensive lookup
+                let current = match op.parent_hash {
+                    Some(parent) => worker_lookup.get(&parent),
+                    None => Some(&self.root),
+                };
+
+                let mut current = match current {
+                    Some(current) => current.clone(),
+                    None => {
+                        log::warn!(
+                            worker_id = worker_id.to_string(),
+                            id,
+                            parent_hash = ?op.parent_hash,
+                            "Failed to find parent block; skipping store operation"
+                        );
+                        return;
+                    }
+                };
+
+                for block_id in op.blocks {
+                    let mut inner = current.borrow_mut();
+                    let block = match inner.children.get(&block_id.tokens_hash) {
+                        Some(block) => block.clone(),
+                        None => {
+                            // create new block - automatically added to the lookup table
+                            let new_block = worker_lookup
+                                .get(&block_id.block_hash)
+                                .cloned()
+                                .unwrap_or_else(|| Rc::new(RefCell::new(RadixBlock::new())));
+
+                            // insert into radix tree
+                            inner
+                                .children
+                                .insert(block_id.tokens_hash, new_block.clone());
+
+                            new_block
+                        }
+                    };
+
+                    // add our worker_id to the block
+                    block.borrow_mut().workers.insert(worker_id);
+
+                    // add the block to the worker_id lookup table
+                    worker_lookup.insert(block_id.block_hash, block.clone());
+
+                    // drop inner so we can shift current to this block
+                    drop(inner);
+
+                    current = block;
+                }
+            }
+            KvCacheEventData::Removed(remove) => {
+                // log::trace!(id, "KV Remove Operation: {:?}", op);
+                // let mut worker_lookup = self.lookup.get(&worker_id).expect("Worker not found");
+
+                for block in remove.block_hashes {
+                    // entry in radix tree
+                    // a small optimization would be to get the next block from the reduced set of children
+                    // in order to apply this optimization, we would need to know the list of blocks is always sorted
+                    // by parent -> child relationship
+                    let entry = match worker_lookup.get(&block) {
+                        Some(entry) => entry.clone(),
+                        None => {
+                            log::warn!(
+                                worker_id = worker_id.to_string(),
+                                id,
+                                "Failed to find block to remove; skipping remove operation"
+                            );
+                            continue;
+                        }
+                    };
+
+                    let mut guard = entry.borrow_mut();
+                    guard.workers.remove(&worker_id);
+                    if guard.workers.is_empty() {
+                        // if no worker are using this block, that is true for all children
+                        guard.children.clear();
+                    }
+                    // remove the block from the lookup table
+                    worker_lookup.remove(&block);
+                }
+            }
+        }
+    }
+
+    pub fn remove_worker(&mut self, worker: WorkerId) {
+        if let Some((_, blocks)) = self.lookup.remove_entry(&worker) {
+            blocks.iter().for_each(|(_, block)| {
+                block.borrow_mut().workers.remove(&worker);
+            });
+        }
+    }
+}
+
+/// Scores representing the overlap of workers.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OverlapScores {
+    // map of worker_id to score
+    pub scores: HashMap<WorkerId, u32>,
+    // List of frequencies that the blocks have been accessed. Entries with value 0 are omitted.
+    pub frequencies: Vec<usize>,
+}
+
+impl Default for OverlapScores {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl OverlapScores {
+    /// Create a new `OverlapScores`.
+    ///
+    /// ### Returns
+    ///
+    /// A new `OverlapScores`.
+    pub fn new() -> Self {
+        Self {
+            scores: HashMap::new(),
+            frequencies: Vec::with_capacity(32),
+        }
+    }
+
+    /// Update the scores with a set of workers.
+    ///
+    /// ### Arguments
+    ///
+    /// * `workers` - A reference to a `HashSet` of `WorkerId`s.
+    pub fn update_scores(&mut self, workers: &HashSet<WorkerId>) {
+        for worker in workers {
+            let score = self.scores.entry(*worker).or_insert(0);
+            *score += 1;
+        }
+    }
+
+    /// Add an entry in the frequency list.
+    pub fn add_frequency(&mut self, frequency: usize) {
+        if frequency != 0 {
+            self.frequencies
+                .last()
+                .inspect(|elem| debug_assert!(**elem >= frequency));
+            self.frequencies.push(frequency);
+        }
+    }
+}
+
+/// A request to find matches in the Radix Tree.
+pub struct MatchRequest {
+    /// A vector of `LocalBlockHash` representing the sequence to match.
+    sequence: Vec<LocalBlockHash>,
+    /// A boolean indicating whether to exit early if a single match is found.
+    early_exit: bool,
+    /// A channel sender to send the `OverlapScores` response.
+    resp: oneshot::Sender<OverlapScores>,
+}
+
+#[async_trait]
+pub trait KvIndexerInterface {
+    /// Find matches for a given sequence of `LocalBlockHash`es.
+    ///
+    /// ### Arguments
+    ///
+    /// * `sequence` - A vector of `LocalBlockHash` representing the sequence to match.
+    ///
+    /// ### Returns
+    ///
+    /// An `OverlapScores` representing the match scores.
+    async fn find_matches(
+        &self,
+        sequence: Vec<LocalBlockHash>,
+    ) -> Result<OverlapScores, KvRouterError>;
+
+    /// Find matches for a given sequence of tokens.
+    ///
+    /// ### Arguments
+    ///
+    /// * `tokens` - A vector of `u32` tokens.
+    ///
+    /// ### Returns
+    ///
+    /// An `OverlapScores` representing the match scores.
+    async fn find_matches_for_request(
+        &self,
+        tokens: &[u32],
+    ) -> Result<OverlapScores, KvRouterError>;
+
+    /// Apply a `RouterEvent` to the KV store.
+    ///
+    /// ### Arguments
+    ///
+    /// * `event` - The `RouterEvent` to apply.
+    async fn apply_event(&mut self, event: RouterEvent);
+
+    /// Remove a worker's entries from the trie.
+    ///
+    /// ### Arguments
+    ///
+    /// * `worker` - The worker to remove from the trie.
+    async fn remove_worker(&mut self, worker: WorkerId);
+
+    /// Shutdown the KV Indexer.
+    fn shutdown(&mut self);
+}
+
+/// The KV Indexer, managing the KV store and handling events and match requests.
+pub struct KvIndexer {
+    /// A `CancellationToken` for managing shutdown.
+    cancel: CancellationToken,
+    /// A sender for `RouterEvent`s.
+    event_tx: mpsc::Sender<RouterEvent>,
+    /// A sender for `MatchRequest`s.
+    match_tx: mpsc::Sender<MatchRequest>,
+    /// A sender for remove worker requests.
+    remove_worker_tx: mpsc::Sender<WorkerId>,
+    /// A handle to the background task managing the KV store.
+    task: OnceLock<std::thread::JoinHandle<()>>,
+}
+
+impl KvIndexer {
+    /// Create a new `KvIndexer`.
+    ///
+    /// ### Arguments
+    ///
+    /// * `token` - A `CancellationToken` for managing shutdown.
+    /// * `expiration_duration` - The amount of time that block usage should be buffered.
+    ///
+    /// ### Returns
+    ///
+    /// A new `KvIndexer`.
+    pub fn new_with_frequency(
+        token: CancellationToken,
+        expiration_duration: Option<Duration>,
+    ) -> Self {
+        let (event_tx, event_rx) = mpsc::channel::<RouterEvent>(2048);
+        let (match_tx, match_rx) = mpsc::channel::<MatchRequest>(128);
+        let (remove_worker_tx, remove_worker_rx) = mpsc::channel::<WorkerId>(16);
+        let cancel_clone = token.clone();
+        let task = std::thread::spawn(move || {
+            // create a new tokio runtime which will only perform work on a single thread
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .worker_threads(1) // Single-threaded environment
+                .enable_all()
+                .build()
+                .unwrap();
+
+            let local_set = tokio::task::LocalSet::new();
+
+            runtime.block_on(local_set.run_until(async move {
+                tokio::task::spawn_local(async move {
+                    let cancel = cancel_clone;
+                    let mut match_rx = match_rx;
+                    let mut event_rx = event_rx;
+                    let mut remove_worker_rx = remove_worker_rx;
+                    let mut trie = RadixTree::new_with_frequency(expiration_duration);
+                    loop {
+                        tokio::select! {
+                            biased;
+
+                            Some(worker) = remove_worker_rx.recv() => {
+                                trie.remove_worker(worker);
+                            }
+
+                            Some(req) = match_rx.recv() => {
+                                let matches = trie.find_matches(req.sequence, req.early_exit);
+                                let _ = req.resp.send(matches);
+                            }
+
+                            _ = cancel.cancelled() => {
+                                log::debug!("KvCacheIndexer progress loop shutting down");
+                                return;
+                            }
+
+                            Some(event) = event_rx.recv() => {
+                                trie.apply_event(event);
+                            }
+                        }
+                    }
+                })
+                .await
+                .unwrap()
+            }));
+
+            log::debug!("KvCacheIndexer task completed");
+        });
+
+        let once = OnceLock::new();
+        once.set(task).unwrap();
+
+        Self {
+            cancel: token,
+            event_tx,
+            match_tx,
+            remove_worker_tx,
+            task: once,
+        }
+    }
+
+    pub fn new(token: CancellationToken) -> Self {
+        Self::new_with_frequency(token, None)
+    }
+
+    /// Get a sender for `RouterEvent`s.
+    ///
+    /// ### Returns
+    ///
+    /// A `mpsc::Sender` for `RouterEvent`s.
+    pub fn event_sender(&self) -> mpsc::Sender<RouterEvent> {
+        self.event_tx.clone()
+    }
+}
+
+#[async_trait]
+impl KvIndexerInterface for KvIndexer {
+    async fn find_matches(
+        &self,
+        sequence: Vec<LocalBlockHash>,
+    ) -> Result<OverlapScores, KvRouterError> {
+        let (resp_tx, resp_rx) = oneshot::channel();
+        let req = MatchRequest {
+            sequence,
+            early_exit: false,
+            resp: resp_tx,
+        };
+
+        if let Err(e) = self.match_tx.send(req).await {
+            log::error!(
+                "Failed to send match request: {:?}; the indexer maybe offline",
+                e
+            );
+            return Err(KvRouterError::IndexerOffline);
+        }
+
+        resp_rx
+            .await
+            .map_err(|_| KvRouterError::IndexerDroppedRequest)
+    }
+
+    async fn find_matches_for_request(
+        &self,
+        tokens: &[u32],
+    ) -> Result<OverlapScores, KvRouterError> {
+        log::debug!(
+            "Finding matches for request tokens: {:?} / len: {}",
+            tokens,
+            tokens.len()
+        );
+        let sequence = compute_block_hash_for_seq(tokens);
+        log::debug!("Computed sequence: {:?}", sequence);
+        self.find_matches(sequence).await
+    }
+
+    async fn apply_event(&mut self, event: RouterEvent) {
+        self.event_tx.send(event).await.unwrap();
+    }
+
+    async fn remove_worker(&mut self, worker: WorkerId) {
+        self.remove_worker_tx.send(worker).await.unwrap();
+    }
+
+    fn shutdown(&mut self) {
+        self.cancel.cancel();
+        if let Some(task) = self.task.take() {
+            task.join().expect("Failed to join kv indexer task");
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ShardedMatchRequest {
+    sequence: Vec<LocalBlockHash>,
+    early_exit: bool,
+    resp: mpsc::Sender<OverlapScores>,
+}
+
+/// The KV Indexer, managing the KV store and handling events and match requests.
+pub struct KvIndexerSharded {
+    /// A `CancellationToken` for managing shutdown.
+    cancel: CancellationToken,
+    worker_assignments: HashMap<WorkerId, usize>,
+    worker_counts: Vec<usize>,
+
+    event_tx: Vec<mpsc::Sender<RouterEvent>>,
+    request_broadcast_tx: broadcast::Sender<ShardedMatchRequest>,
+    remove_worker_tx: Vec<mpsc::Sender<WorkerId>>,
+    tasks: Vec<JoinHandle<()>>,
+}
+
+impl KvIndexerSharded {
+    /// Create a new `KvIndexerSharded`.
+    ///
+    /// ### Arguments
+    ///
+    /// * `token` - A `CancellationToken` for managing shutdown.
+    /// * `shards` - A list of kvindexer shards.
+    /// * `expiration_duration` - The amount of time that block usage should be buffered.
+    ///
+    /// ### Returns
+    ///
+    /// A new `KvIndexer`.
+    pub fn new_with_frequency(
+        token: CancellationToken,
+        num_shards: usize,
+        expiration_duration: Option<Duration>,
+    ) -> Self {
+        let worker_assignments: HashMap<WorkerId, usize> = HashMap::new();
+        let worker_counts: Vec<usize> = vec![0; num_shards];
+
+        let mut event_tx = Vec::new();
+        let mut remove_worker_tx = Vec::new();
+        let mut tasks = Vec::new();
+
+        let (request_broadcast_tx, _) = broadcast::channel::<ShardedMatchRequest>(1048576);
+
+        for _ in 0..num_shards {
+            let (shard_event_tx, mut shard_event_rx) = mpsc::channel::<RouterEvent>(2048);
+            let (shard_remove_worker_tx, mut shard_remove_worker_rx) =
+                mpsc::channel::<WorkerId>(16);
+            let mut shard_broadcast_rx = request_broadcast_tx.subscribe();
+            let cancel = token.clone();
+
+            event_tx.push(shard_event_tx);
+            remove_worker_tx.push(shard_remove_worker_tx);
+
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .worker_threads(1)
+                .enable_all()
+                .build()
+                .unwrap();
+
+            tasks.push(std::thread::spawn(move || {
+                let local_set = tokio::task::LocalSet::new();
+
+                runtime.block_on(local_set.run_until(async move {
+                    tokio::task::spawn_local(async move {
+                        let mut trie = RadixTree::new_with_frequency(expiration_duration);
+                        loop {
+                            tokio::select! {
+                                biased;
+
+                                Some(worker) = shard_remove_worker_rx.recv() => {
+                                    trie.remove_worker(worker);
+                                }
+
+                                Ok(req) = shard_broadcast_rx.recv() => {
+                                    let matches = trie.find_matches(req.sequence, req.early_exit);
+                                    if let Err(e) = req.resp.send(matches).await {
+                                        log::trace!("Failed to send match response: {:?}", e);
+                                    }
+                                }
+
+                                _ = cancel.cancelled() => {
+                                    log::debug!("KvCacheIndexer progress loop shutting down");
+                                    return;
+                                }
+
+                                Some(event) = shard_event_rx.recv() => {
+                                    trie.apply_event(event);
+                                }
+                            }
+                        }
+                    })
+                    .await
+                    .unwrap()
+                }));
+
+                log::debug!("KvCacheIndexer task completed");
+            }));
+        }
+
+        Self {
+            cancel: token,
+            worker_assignments,
+            worker_counts,
+            event_tx,
+            request_broadcast_tx,
+            remove_worker_tx,
+            tasks,
+        }
+    }
+
+    pub fn new(token: CancellationToken, num_shards: usize) -> Self {
+        Self::new_with_frequency(token, num_shards, None)
+    }
+}
+
+#[async_trait]
+impl KvIndexerInterface for KvIndexerSharded {
+    async fn find_matches(
+        &self,
+        sequence: Vec<LocalBlockHash>,
+    ) -> Result<OverlapScores, KvRouterError> {
+        'match_loop: loop {
+            let (match_tx, mut match_rx) = mpsc::channel(self.event_tx.len());
+            self.request_broadcast_tx
+                .send(ShardedMatchRequest {
+                    sequence: sequence.clone(),
+                    early_exit: false,
+                    resp: match_tx,
+                })
+                .map_err(|_| KvRouterError::IndexerOffline)?;
+
+            let mut scores = OverlapScores::new();
+
+            for response_num in 0..self.event_tx.len() {
+                match match_rx.recv().await {
+                    Some(response) => {
+                        scores.scores.extend(response.scores);
+
+                        if response_num == 0 {
+                            scores.frequencies = response.frequencies;
+                        } else {
+                            let diff = (response.frequencies.len() as i64)
+                                - (scores.frequencies.len() as i64);
+
+                            if diff > 0 {
+                                scores
+                                    .frequencies
+                                    .extend(iter::repeat(0).take(diff as usize));
+                            }
+
+                            for i in 0..response.frequencies.len() {
+                                scores.frequencies[i] += response.frequencies[i];
+                            }
+                        }
+                    }
+                    None => {
+                        // This can only happen if the broadcast channel overflows.
+                        // In this case, we don't want to recursively call find_matches again. Otherwise, we could overflow the stack.
+                        continue 'match_loop;
+                    }
+                }
+            }
+            return Ok(scores);
+        }
+    }
+
+    async fn find_matches_for_request(
+        &self,
+        tokens: &[u32],
+    ) -> Result<OverlapScores, KvRouterError> {
+        let sequence = compute_block_hash_for_seq(tokens);
+        self.find_matches(sequence).await
+    }
+
+    async fn apply_event(&mut self, event: RouterEvent) {
+        #[allow(clippy::map_entry)]
+        if !self.worker_assignments.contains_key(&event.worker_id) {
+            // Get the shard with the smallest amount of workers.
+            let selected_shard = self
+                .worker_counts
+                .iter()
+                .enumerate()
+                .min_by_key(|&(_, value)| value)
+                .unwrap()
+                .0;
+
+            self.worker_assignments
+                .insert(event.worker_id, selected_shard);
+            self.worker_counts[selected_shard] += 1;
+        }
+
+        self.event_tx[self.worker_assignments[&event.worker_id]]
+            .send(event)
+            .await
+            .unwrap();
+    }
+
+    async fn remove_worker(&mut self, worker: WorkerId) {
+        if let Some((_, shard)) = self.worker_assignments.remove_entry(&worker) {
+            self.worker_counts[shard] -= 1;
+            self.remove_worker_tx[shard].send(worker).await.unwrap();
+        }
+    }
+
+    /// Shutdown the KV Indexer.
+    fn shutdown(&mut self) {
+        self.cancel.cancel();
+        while !self.tasks.is_empty() {
+            self.tasks.pop().unwrap().join().unwrap();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use rstest::rstest;
+    use tokio::time;
+    use tokio_util::sync::CancellationToken;
+
+    fn make_blocks(hashes: Vec<u64>) -> Vec<KvCacheStoredBlockData> {
+        hashes
+            .iter()
+            .map(|i| KvCacheStoredBlockData {
+                tokens_hash: LocalBlockHash(*i),
+                block_hash: ExternalSequenceBlockHash(*i * 100),
+            })
+            .collect()
+    }
+
+    fn add_blocks(
+        hashes: Vec<u64>,
+        parent_hash: Option<ExternalSequenceBlockHash>,
+    ) -> KvCacheEventData {
+        KvCacheEventData::Stored(KvCacheStoreData {
+            parent_hash,
+            blocks: make_blocks(hashes),
+        })
+    }
+
+    fn create_store_event(
+        worker_id: WorkerId,
+        event_id: u64,
+        hashes: Vec<u64>,
+        parent: Option<ExternalSequenceBlockHash>,
+    ) -> RouterEvent {
+        RouterEvent {
+            worker_id,
+            event: KvCacheEvent {
+                event_id,
+                data: add_blocks(hashes, parent),
+            },
+        }
+    }
+
+    fn create_remove_event(worker_id: WorkerId, event_id: u64, hashes: Vec<u64>) -> RouterEvent {
+        RouterEvent {
+            worker_id,
+            event: KvCacheEvent {
+                event_id,
+                data: KvCacheEventData::Removed(KvCacheRemoveData {
+                    block_hashes: hashes
+                        .iter()
+                        .map(|i| ExternalSequenceBlockHash(*i * 100))
+                        .collect(),
+                }),
+            },
+        }
+    }
+
+    #[test]
+    fn test_radix_tree() {
+        let mut trie = RadixTree::new();
+
+        let worker_1 = uuid::Uuid::new_v4();
+        let worker_2 = uuid::Uuid::new_v4();
+
+        trie.apply_event(create_store_event(worker_1, 1, vec![1, 2, 3], None));
+
+        let scores = trie.find_matches(
+            vec![LocalBlockHash(1), LocalBlockHash(2), LocalBlockHash(3)],
+            false,
+        );
+        assert_eq!(scores.scores.get(&worker_1).unwrap(), &3);
+
+        assert_eq!(trie.lookup.len(), 1);
+        assert_eq!(trie.lookup.get(&worker_1).unwrap().len(), 3);
+        assert_eq!(trie.root.borrow().workers.len(), 0);
+        assert_eq!(trie.root.borrow().children.len(), 1);
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            1
+        );
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .children
+                .len(),
+            1
+        );
+
+        trie.apply_event(create_store_event(worker_2, 1, vec![1, 4, 5], None));
+
+        let scores = trie.find_matches(
+            vec![LocalBlockHash(1), LocalBlockHash(2), LocalBlockHash(3)],
+            false,
+        );
+        assert_eq!(scores.scores.get(&worker_1).unwrap(), &3);
+        assert_eq!(scores.scores.get(&worker_2).unwrap(), &1);
+
+        assert_eq!(trie.lookup.len(), 2);
+        assert_eq!(trie.lookup.get(&worker_1).unwrap().len(), 3);
+        assert_eq!(trie.lookup.get(&worker_2).unwrap().len(), 3);
+        assert_eq!(trie.root.borrow().workers.len(), 0);
+        assert_eq!(trie.root.borrow().children.len(), 1);
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .children
+                .len(),
+            2
+        );
+
+        trie.apply_event(create_remove_event(worker_2, 2, vec![5]));
+        assert_eq!(trie.lookup.len(), 2);
+        assert_eq!(trie.lookup.get(&worker_1).unwrap().len(), 3);
+        assert_eq!(trie.lookup.get(&worker_2).unwrap().len(), 2);
+        assert_eq!(trie.root.borrow().workers.len(), 0);
+        assert_eq!(trie.root.borrow().children.len(), 1);
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .children
+                .len(),
+            2
+        );
+
+        trie.apply_event(create_remove_event(worker_2, 3, vec![4]));
+
+        assert_eq!(trie.lookup.len(), 2);
+        assert_eq!(trie.lookup.get(&worker_1).unwrap().len(), 3);
+        assert_eq!(trie.lookup.get(&worker_2).unwrap().len(), 1);
+        assert_eq!(trie.root.borrow().workers.len(), 0);
+        assert_eq!(trie.root.borrow().children.len(), 1);
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .children
+                .len(),
+            2
+        );
+
+        trie.apply_event(create_store_event(
+            worker_2,
+            4,
+            vec![2, 6, 7],
+            Some(ExternalSequenceBlockHash(100)),
+        ));
+
+        let scores = trie.find_matches(
+            vec![LocalBlockHash(1), LocalBlockHash(2), LocalBlockHash(3)],
+            false,
+        );
+        assert_eq!(scores.scores.get(&worker_1).unwrap(), &3);
+        assert_eq!(scores.scores.get(&worker_2).unwrap(), &2);
+
+        assert_eq!(trie.lookup.len(), 2);
+        assert_eq!(trie.lookup.get(&worker_1).unwrap().len(), 3);
+        assert_eq!(trie.lookup.get(&worker_2).unwrap().len(), 4);
+        assert_eq!(trie.root.borrow().workers.len(), 0);
+        assert_eq!(trie.root.borrow().children.len(), 1);
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.root
+                .borrow()
+                .children
+                .get(&LocalBlockHash(1))
+                .unwrap()
+                .borrow()
+                .children
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.lookup
+                .get(&worker_1)
+                .unwrap()
+                .get(&ExternalSequenceBlockHash(200))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+        assert_eq!(
+            trie.lookup
+                .get(&worker_2)
+                .unwrap()
+                .get(&ExternalSequenceBlockHash(200))
+                .unwrap()
+                .borrow()
+                .workers
+                .len(),
+            2
+        );
+    }
+
+    #[test]
+    fn test_remove_worker() {
+        let mut trie = RadixTree::new();
+
+        let worker_0 = uuid::Uuid::new_v4();
+        let worker_1 = uuid::Uuid::new_v4();
+
+        assert!(trie
+            .find_matches(vec![LocalBlockHash(0)], false)
+            .scores
+            .is_empty());
+
+        trie.apply_event(create_store_event(worker_0, 0, vec![0], None));
+        trie.apply_event(create_store_event(worker_1, 0, vec![0], None));
+
+        let result = trie.find_matches(vec![LocalBlockHash(0)], false).scores;
+        assert!(result.len() == 2 && result[&worker_0] == 1 && result[&worker_1] == 1);
+
+        trie.remove_worker(worker_0);
+
+        let result = trie.find_matches(vec![LocalBlockHash(0)], false).scores;
+        assert!(result.len() == 1 && result[&worker_1] == 1);
+    }
+
+    #[test]
+    fn test_early_stopping() {
+        let mut trie = RadixTree::new();
+
+        let worker_0 = uuid::Uuid::new_v4();
+        let worker_1 = uuid::Uuid::new_v4();
+
+        trie.apply_event(create_store_event(worker_0, 0, vec![0, 1, 2], None));
+        trie.apply_event(create_store_event(worker_1, 0, vec![0], None));
+
+        let result = trie
+            .find_matches(
+                vec![LocalBlockHash(0), LocalBlockHash(1), LocalBlockHash(2)],
+                true,
+            )
+            .scores;
+
+        assert!(result.len() == 2 && result[&worker_0] == 2 && result[&worker_1] == 1);
+
+        let result = trie
+            .find_matches(vec![LocalBlockHash(0), LocalBlockHash(1)], true)
+            .scores;
+        assert!(result.len() == 2 && result[&worker_0] == 2 && result[&worker_1] == 1);
+    }
+
+    #[test]
+    fn test_compute_block_hash_for_seq() {
+        // create a sequence of 64 elements
+        let sequence = (0..KV_BLOCK_SIZE).map(|i| i as u32).collect::<Vec<u32>>();
+        let hashes = compute_block_hash_for_seq(&sequence);
+        assert_eq!(hashes.len(), 1);
+
+        // create a sequence of 65 elements
+        let sequence = (0..(KV_BLOCK_SIZE + 1)).map(|i| i as u32).collect::<Vec<u32>>();
+        let hashes = compute_block_hash_for_seq(&sequence);
+        assert_eq!(hashes.len(), 1);
+
+        // create a sequence of 129 elements
+        let sequence = (0..(2 * KV_BLOCK_SIZE + 1)).map(|i| i as u32).collect::<Vec<u32>>();
+        let hashes = compute_block_hash_for_seq(&sequence);
+        assert_eq!(hashes.len(), 2);
+    }
+
+    fn make_indexer(token: &CancellationToken, num_shards: usize) -> Box<dyn KvIndexerInterface> {
+        if num_shards == 1 {
+            Box::new(KvIndexer::new(token.clone()))
+        } else {
+            Box::new(KvIndexerSharded::new(token.clone(), num_shards))
+        }
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_kv_indexer_new(#[case] num_shards: usize) {
+        let token = CancellationToken::new();
+        let _ = make_indexer(&token, num_shards);
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_find_matches(#[case] num_shards: usize) {
+        let token = CancellationToken::new();
+        let kv_indexer = make_indexer(&token, num_shards);
+
+        let sequence = vec![compute_block_hash(b"test data")];
+        let scores = kv_indexer.find_matches(sequence).await;
+
+        assert!(scores.unwrap().scores.is_empty());
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_find_matches_for_request(#[case] num_shards: usize) {
+        let token = CancellationToken::new();
+        let kv_indexer = make_indexer(&token, num_shards);
+
+        let tokens = vec![1, 2, 3, 4];
+        let scores = kv_indexer.find_matches_for_request(&tokens).await;
+
+        assert!(scores.unwrap().scores.is_empty());
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_apply_event(#[case] num_shards: usize) {
+        let worker_id = uuid::Uuid::new_v4();
+
+        let token = CancellationToken::new();
+        let mut kv_indexer = make_indexer(&token, num_shards);
+
+        let event = create_store_event(worker_id, 1, vec![1, 2, 3], None);
+        kv_indexer.apply_event(event).await;
+
+        // No assertion here, just ensuring it runs without panic
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_shutdown(#[case] num_shards: usize) {
+        let token = CancellationToken::new();
+        let mut kv_indexer = make_indexer(&token, num_shards);
+
+        kv_indexer.shutdown();
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(2)]
+    #[case(3)]
+    #[case(4)]
+    #[case(5)]
+    #[case(6)]
+    #[case(7)]
+    #[case(8)]
+    #[tokio::test]
+    async fn test_frequency(#[case] num_shards: usize) {
+        let mut kv_indexer: Box<dyn KvIndexerInterface>;
+        let token = CancellationToken::new();
+        let duration = Some(Duration::from_millis(50));
+
+        if num_shards == 1 {
+            kv_indexer = Box::new(KvIndexer::new_with_frequency(token, duration));
+        } else {
+            kv_indexer = Box::new(KvIndexerSharded::new_with_frequency(
+                token, num_shards, duration,
+            ));
+        }
+
+        let worker_id = uuid::Uuid::new_v4();
+
+        let event = create_store_event(worker_id, 0, vec![1, 2, 3, 4], None);
+        kv_indexer.apply_event(event).await;
+
+        time::sleep(Duration::from_millis(5)).await;
+
+        let block_hashes = vec![
+            LocalBlockHash(1),
+            LocalBlockHash(2),
+            LocalBlockHash(3),
+            LocalBlockHash(4),
+        ];
+        let scores = kv_indexer.find_matches(block_hashes.clone()).await.unwrap();
+
+        assert_eq!(scores.frequencies.len(), 0);
+
+        let scores = kv_indexer.find_matches(block_hashes.clone()).await.unwrap();
+        assert_eq!(scores.frequencies, vec![1, 1, 1, 1]);
+
+        time::sleep(Duration::from_millis(100)).await;
+
+        let scores = kv_indexer.find_matches(block_hashes.clone()).await.unwrap();
+        assert_eq!(scores.frequencies.len(), 0);
+
+        let scores = kv_indexer.find_matches(block_hashes.clone()).await.unwrap();
+        assert_eq!(scores.frequencies, vec![1, 1, 1, 1]);
+
+        let scores = kv_indexer
+            .find_matches(block_hashes[0..3].to_vec())
+            .await
+            .unwrap();
+        assert_eq!(scores.frequencies, vec![2, 2, 2]);
+
+        let scores = kv_indexer.find_matches(block_hashes.clone()).await.unwrap();
+        assert_eq!(scores.frequencies, vec![3, 3, 3, 2]);
+    }
+
+    #[test]
+    fn test_router_event_new() {
+        let worker_id = uuid::Uuid::new_v4();
+        let kv_cache_event = KvCacheEvent {
+            event_id: 1,
+            data: KvCacheEventData::Stored(KvCacheStoreData {
+                parent_hash: None,
+                blocks: vec![KvCacheStoredBlockData {
+                    block_hash: ExternalSequenceBlockHash(0),
+                    tokens_hash: LocalBlockHash(13226331709069118873),
+                }],
+            }),
+        };
+        let router_event = RouterEvent::new(worker_id, kv_cache_event);
+
+        assert_eq!(router_event.worker_id, worker_id);
+        assert_eq!(router_event.event.event_id, 1);
+        if let KvCacheEventData::Stored(store_op) = &router_event.event.data {
+            assert_eq!(store_op.blocks.len(), 1);
+            assert_eq!(
+                store_op.blocks[0].tokens_hash,
+                compute_block_hash(b"test data")
+            );
+            assert_eq!(store_op.blocks[0].block_hash, ExternalSequenceBlockHash(0));
+        } else {
+            panic!("Expected KvCacheEventData::Stored");
+        }
+    }
+
+    #[test]
+    fn test_radix_tree_default() {
+        let radix_tree: RadixTree = Default::default();
+        assert!(radix_tree.root.borrow().children.is_empty());
+        assert!(radix_tree.root.borrow().workers.is_empty());
+        assert!(radix_tree.lookup.is_empty());
+    }
+
+    #[test]
+    fn test_overlap_scores_default() {
+        let overlap_scores: OverlapScores = Default::default();
+        assert!(overlap_scores.scores.is_empty());
+    }
+}

llm/rust/triton-llm/src/kv_router/protocols.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use serde::{Deserialize, Serialize};
+
+// Currently hard-coding the block size to be 64 tokens, and
+// assuming the LLM framework aligns with this size.
+// The KV publisher and subscriber conveys hash values of the tokens,
+// for performance reason, therefore the block size needs to be consistent
+// so that the computed hash value is the same on both sizes.
+pub const KV_BLOCK_SIZE: usize = 64;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ForwardPassMetrics {
+    pub request_active_slots: u64,
+    pub request_total_slots: u64,
+    pub kv_active_blocks: u64,
+    pub kv_total_blocks: u64,
+}
+
+/// A [`BlockHash`] is a hash computed from the tokens_ids, extra_token_ids and the optional
+/// lora_id of a block.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct LocalBlockHash(pub u64);
+
+/// A sequence aware hash of a block where the hash is computed from the tokens_ids, extra_token_ids
+/// and the optional lora_id of a block, PLUS the hash of the parent block.
+///
+/// In this case, the hashing function is external and unknown.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ExternalSequenceBlockHash(pub u64);
+
+/// Represents a collection of cache events and a shutdown flag.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct KvCacheEvents {
+    /// A list of cache events.
+    pub events: Vec<KvCacheEvent>,
+    /// A flag indicating whether the cache is shutting down.
+    pub shutdown: bool,
+}
+
+/// Represents a single cache event with an ID and associated data.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct KvCacheEvent {
+    /// The unique identifier of the event.
+    pub event_id: u64,
+    /// The data associated with the event.
+    pub data: KvCacheEventData,
+}
+
+/// Represents the data associated with a cache event.
+///
+/// Data is either stored or removed.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum KvCacheEventData {
+    /// Data for a stored cache event.
+    Stored(KvCacheStoreData),
+    /// Data for a removed cache event.
+    Removed(KvCacheRemoveData),
+}
+
+/// Represents the data associated with a stored cache event.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct KvCacheStoreData {
+    /// The optional hash of the parent block.
+    pub parent_hash: Option<ExternalSequenceBlockHash>,
+    /// A list of stored blocked data.
+    pub blocks: Vec<KvCacheStoredBlockData>,
+}
+
+/// Represents data for a stored block.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct KvCacheStoredBlockData {
+    /// The hash of the block.
+    pub block_hash: ExternalSequenceBlockHash,
+    /// The hash of the tokens in the block.
+    pub tokens_hash: LocalBlockHash,
+}
+
+/// Represents the data associated with a removed cache event.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct KvCacheRemoveData {
+    /// A list of block hashes to remove.
+    pub block_hashes: Vec<ExternalSequenceBlockHash>,
+}
+
+impl Serialize for LocalBlockHash {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u64(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for LocalBlockHash {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = u64::deserialize(deserializer)?;
+        Ok(LocalBlockHash(value))
+    }
+}
+
+impl Serialize for ExternalSequenceBlockHash {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u64(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for ExternalSequenceBlockHash {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = u64::deserialize(deserializer)?;
+        Ok(ExternalSequenceBlockHash(value))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json;
+
+    #[test]
+    fn test_local_block_hash_serialization() {
+        let hash = LocalBlockHash(12345);
+        let serialized = serde_json::to_string(&hash).unwrap();
+        assert_eq!(serialized, "12345");
+
+        let deserialized: LocalBlockHash = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, hash);
+    }
+
+    #[test]
+    fn test_external_sequence_block_hash_serialization() {
+        let hash = ExternalSequenceBlockHash(67890);
+        let serialized = serde_json::to_string(&hash).unwrap();
+        assert_eq!(serialized, "67890");
+
+        let deserialized: ExternalSequenceBlockHash = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, hash);
+    }
+
+    #[test]
+    fn test_kv_cache_events_serialization() {
+        let event_data = KvCacheEventData::Stored(KvCacheStoreData {
+            parent_hash: Some(ExternalSequenceBlockHash(1)),
+            blocks: vec![KvCacheStoredBlockData {
+                block_hash: ExternalSequenceBlockHash(2),
+                tokens_hash: LocalBlockHash(3),
+            }],
+        });
+
+        let event = KvCacheEvent {
+            event_id: 1,
+            data: event_data,
+        };
+
+        let events = KvCacheEvents {
+            events: vec![event],
+            shutdown: false,
+        };
+
+        let serialized = serde_json::to_string(&events).unwrap();
+        let deserialized: KvCacheEvents = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(deserialized.events.len(), 1);
+        assert_eq!(deserialized.events[0].event_id, 1);
+        if let KvCacheEventData::Stored(store_data) = &deserialized.events[0].data {
+            assert_eq!(store_data.parent_hash.unwrap().0, 1);
+            assert_eq!(store_data.blocks.len(), 1);
+            assert_eq!(store_data.blocks[0].block_hash.0, 2);
+            assert_eq!(store_data.blocks[0].tokens_hash.0, 3);
+        } else {
+            panic!("Expected KvCacheEventData::Stored variant");
+        }
+        assert!(!deserialized.shutdown);
+    }
+
+    #[test]
+    fn test_kv_cache_remove_data_serialization() {
+        let remove_data = KvCacheRemoveData {
+            block_hashes: vec![ExternalSequenceBlockHash(4), ExternalSequenceBlockHash(5)],
+        };
+
+        let serialized = serde_json::to_string(&remove_data).unwrap();
+        let deserialized: KvCacheRemoveData = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(deserialized.block_hashes.len(), 2);
+        assert_eq!(deserialized.block_hashes[0].0, 4);
+        assert_eq!(deserialized.block_hashes[1].0, 5);
+    }
+}

llm/rust/triton-llm/src/kv_router/publisher.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::kv_router::{indexer::RouterEvent, protocols::KvCacheEvent, KV_EVENT_SUBJECT};
+use tokio::sync::mpsc;
+use triton_distributed::{component::Component, DistributedRuntime, Result};
+use uuid::Uuid;
+use tracing as log;
+
+pub struct KvPublisher {
+    tx: mpsc::UnboundedSender<KvCacheEvent>,
+}
+
+impl KvPublisher {
+    pub fn new(drt: DistributedRuntime, backend: Component, worker_id: Uuid) -> Result<Self> {
+        let (tx, rx) = mpsc::unbounded_channel::<KvCacheEvent>();
+        let p = KvPublisher { tx };
+
+        start_publish_task(drt, backend, worker_id, rx);
+        Ok(p)
+    }
+
+    pub fn publish(&self, event: KvCacheEvent) -> Result<(), mpsc::error::SendError<KvCacheEvent>> {
+        log::debug!("Publish event: {:?}", event);
+        self.tx.send(event)
+    }
+}
+
+fn start_publish_task(
+    drt: DistributedRuntime,
+    backend: Component,
+    worker_id: Uuid,
+    mut rx: mpsc::UnboundedReceiver<KvCacheEvent>,
+) {
+    let client = drt.nats_client().client().clone();
+    // [FIXME] service name is for metrics polling?
+    // let service_name = backend.service_name();
+    let kv_subject = backend.event_subject(KV_EVENT_SUBJECT);
+    log::info!("Publishing KV Events to subject: {}", kv_subject);
+
+    _ = drt.runtime().secondary().spawn(async move {
+        while let Some(event) = rx.recv().await {
+            let router_event = RouterEvent::new(worker_id, event);
+            let data = serde_json::to_string(&router_event).unwrap();
+            client
+                .publish(kv_subject.to_string(), data.into())
+                .await
+                .unwrap();
+        }
+    });
+}

llm/rust/triton-llm/src/kv_router/scheduler.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use serde::{Deserialize, Serialize};
+use std::borrow::BorrowMut;
+use std::cmp::min;
+use tracing as log;
+
+use uuid::Uuid;
+
+use crate::kv_router::indexer::OverlapScores;
+pub use crate::kv_router::protocols::{ForwardPassMetrics, KV_BLOCK_SIZE};
+use crate::kv_router::scoring::ProcessedEndpoints;
+
+#[derive(Debug, thiserror::Error)]
+pub enum KvSchedulerError {
+    #[error("no endpoints aviailable to route work")]
+    NoEndpoints,
+
+    #[error("endpoints existed, but no valid routes were found")]
+    NoRoutes,
+
+    #[error("all workers busy")]
+    AllWorkersBusy,
+
+    #[error("endpoint subscriber shutdown")]
+    SubscriberShutdown,
+
+    #[error("scheduler offline")]
+    SchedulerOffline,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Endpoint {
+    pub name: String,
+    pub subject: String,
+    pub data: ForwardPassMetrics,
+}
+
+impl Endpoint {
+    pub fn worker_id(&self) -> Uuid {
+        Uuid::parse_str(
+            self.subject
+                .split(".")
+                .last()
+                .expect("invalid subject")
+                .to_string()
+                .as_str(),
+        )
+        .expect("invalid uuid")
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Service {
+    pub name: String,
+    pub id: String,
+    pub version: String,
+    pub started: String,
+    pub endpoints: Vec<Endpoint>,
+}
+
+pub struct SchedulingRequest {
+    isl_tokens: usize,
+    overlap: OverlapScores,
+    resp_tx: tokio::sync::oneshot::Sender<String>,
+}
+
+impl SchedulingRequest {
+    pub fn respond(self, worker_id: String) {
+        if self.resp_tx.send(worker_id).is_err() {
+            log::trace!("failed to send response to requestor");
+        }
+    }
+}
+
+pub struct KvScheduler {
+    request_tx: tokio::sync::mpsc::Sender<SchedulingRequest>,
+}
+
+impl KvScheduler {
+    pub async fn start(
+        endpoints_rx: tokio::sync::mpsc::Receiver<ProcessedEndpoints>,
+    ) -> Result<Self, KvSchedulerError> {
+        let mut endpoints_rx = endpoints_rx;
+
+        log::trace!("awaiting the start of the background endpoint subscriber");
+        let mut endpoints = match endpoints_rx.recv().await {
+            Some(endpoints) => endpoints,
+            None => {
+                return Err(KvSchedulerError::SubscriberShutdown);
+            }
+        };
+
+        // Channel to accept new scheduling requests
+        let (request_tx, request_rx) = tokio::sync::mpsc::channel::<SchedulingRequest>(16);
+        log::debug!("scheduler starting");
+        // Background task to handle scheduling requests
+        tokio::spawn(async move {
+            let mut request: SchedulingRequest;
+            let mut request_rx = request_rx;
+            log::debug!("scheduler background task started");
+
+            'outer: loop {
+                request = tokio::select! {
+                    biased;
+
+                    new_request = request_rx.recv() => {
+                        match new_request {
+                            Some(new_request) => {
+                                log::trace!("received request to be scheduled");
+                                new_request
+                            },
+                            None => {
+                                log::trace!("scheduler shutdown");
+                                break 'outer;
+                            }
+                        }
+                    }
+
+                    new_endpoints = endpoints_rx.recv() => {
+                        match new_endpoints {
+                            Some(new_endpoints) => {
+                                log::trace!("updated endpoints");
+                                endpoints = new_endpoints;
+                                continue 'outer;
+                            }
+                            None => {
+                                log::trace!("endpoint subscriber shutdown");
+                                break 'outer;
+                            }
+                        }
+                    }
+                };
+                log::debug!("selected");
+                loop {
+                    match select_worker(endpoints.borrow_mut(), &request) {
+                        Ok(worker_id) => {
+                            request.respond(worker_id);
+                            continue 'outer;
+                        }
+                        Err(KvSchedulerError::AllWorkersBusy) => {
+                            log::trace!("all workers busy; waiting for more capacity");
+                            endpoints = match endpoints_rx.recv().await {
+                                Some(endpoints) => endpoints,
+                                None => {
+                                    log::trace!("endpoint subscriber shutdown");
+                                    break 'outer;
+                                }
+                            };
+                        }
+                        Err(e) => {
+                            log::error!("error scheduling request: {:?}", e);
+                            break 'outer;
+                        }
+                    }
+                }
+            }
+
+            log::trace!("background endpoint subscriber shutting down");
+        });
+
+        Ok(KvScheduler { request_tx })
+    }
+
+    pub async fn schedule(
+        &self,
+        overlap: OverlapScores,
+        isl_tokens: usize,
+    ) -> Result<String, KvSchedulerError> {
+        let (resp_tx, resp_rx) = tokio::sync::oneshot::channel();
+        let request = SchedulingRequest {
+            isl_tokens,
+            overlap,
+            resp_tx,
+        };
+        log::debug!("before sending request");
+        self.request_tx
+            .send(request)
+            .await
+            .map_err(|_| KvSchedulerError::SubscriberShutdown)?;
+        log::debug!("after sending request");
+
+        let res = resp_rx
+            .await
+            .map_err(|_| KvSchedulerError::SubscriberShutdown)?;
+        log::debug!("after receiving response");
+        Ok(res)
+    }
+}
+
+pub fn select_worker(
+    workers: &mut ProcessedEndpoints,
+    request: &SchedulingRequest,
+) -> Result<String, KvSchedulerError> {
+    // balance mode prioritizes balancing load across workers
+    let balance_threshold: f64 = 0.1;
+    let balance_mode = workers.load_std > balance_threshold * workers.load_avg;
+
+    // Determine alpha based on mode
+    let alpha = if balance_mode { 0.7 } else { 0.3 };
+    let gamma = 0.1; // example tuning param
+
+    // Compute each worker's score
+    let mut best_index = None;
+    let mut best_cost = f64::INFINITY;
+
+    if workers.endpoints.is_empty() {
+        return Err(KvSchedulerError::NoEndpoints);
+    }
+
+    for (i, w) in workers.endpoints.iter().enumerate() {
+        // Exclude workers that are at capacity
+        if w.data.request_active_slots >= w.data.request_total_slots
+            || w.data.kv_active_blocks >= w.data.kv_total_blocks
+        {
+            continue;
+        }
+
+        let kv_load_ratio = w.data.kv_active_blocks as f64 / w.data.kv_total_blocks as f64;
+        let load_deviation = kv_load_ratio - workers.load_avg;
+
+        let worker_id = workers.worker_ids[i];
+        let overlap_score = request.overlap.scores.get(&worker_id).map_or(0, |x| *x);
+        let overlap_score = overlap_score as usize * KV_BLOCK_SIZE;
+
+        let new_tokens = request.isl_tokens.saturating_sub(overlap_score);
+        let normalized_new_tokens = new_tokens as f64 / request.isl_tokens as f64;
+
+        let request_load_ratio =
+            w.data.request_active_slots as f64 / w.data.request_total_slots as f64;
+
+        // cost = alpha * load_deviation + (1 - alpha)*normalized_new_tokens + gamma * request_load_ratio
+        let cost = alpha * load_deviation
+            + (1.0 - alpha) * normalized_new_tokens
+            + gamma * request_load_ratio;
+
+        log::debug!("worker: {}; load_deviation: {}; normalized new blocks: {}; request_load_ratio: {} cost: {}",
+                worker_id,
+                load_deviation,
+                normalized_new_tokens,
+                request_load_ratio,
+                cost
+            );
+
+        if cost < best_cost {
+            best_cost = cost;
+            best_index = Some(i);
+        }
+    }
+
+    if let Some(best_index) = best_index {
+        let total_blocks = min(request.isl_tokens / KV_BLOCK_SIZE, 1);
+
+        workers.endpoints[best_index].data.request_active_slots += 1;
+        workers.endpoints[best_index].data.kv_active_blocks += total_blocks as u64;
+    }
+
+    match best_index {
+        Some(i) => {
+            log::info!(
+                "selected worker: {}; cost: {}",
+                workers.endpoints[i].subject,
+                best_cost
+            );
+            Ok(workers.endpoints[i].subject.clone())
+        }
+        None => {
+            log::debug!("all workers busy");
+            Err(KvSchedulerError::AllWorkersBusy)
+        }
+    }
+}

llm/rust/triton-llm/src/kv_router/scoring.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Scoring functions for the KV router.
+
+use std::collections::HashSet;
+
+use crate::kv_router::scheduler::Endpoint;
+use uuid::Uuid;
+
+#[derive(Debug, Default)]
+pub struct ProcessedEndpoints {
+    pub endpoints: Vec<Endpoint>,
+    pub worker_ids: Vec<Uuid>,
+    pub load_avg: f64,
+    pub load_std: f64,
+}
+
+impl ProcessedEndpoints {
+    pub fn new(endpoints: Vec<Endpoint>) -> Self {
+        // compute some basic statistics
+        let load_values: Vec<f64> = endpoints
+            .iter()
+            .map(|x| x.data.kv_active_blocks as f64)
+            .collect();
+        let load_avg = load_values.iter().copied().sum::<f64>() / load_values.len() as f64;
+        let variance = load_values
+            .iter()
+            .map(|&x| (x - load_avg).powi(2))
+            .sum::<f64>()
+            / load_values.len() as f64;
+        let load_std = variance.sqrt();
+
+        let worker_ids: HashSet<Uuid> = endpoints.iter().map(|x| x.worker_id()).collect();
+        let worker_ids: Vec<Uuid> = worker_ids.into_iter().collect();
+
+        ProcessedEndpoints {
+            endpoints,
+            worker_ids,
+            load_avg,
+            load_std,
+        }
+    }
+}

llm/rust/triton-llm/src/kv_router/worker.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+pub use crate::kv_router::protocols::ForwardPassMetrics;
+
+use anyhow::Result;
+use derive_builder::Builder;
+use triton_distributed::pipeline::network::{
+    ingress::push_endpoint::PushEndpoint,
+    PushWorkHandler,
+};
+
+use triton_distributed::transports::nats::{self, ServiceExt};
+
+use tokio::sync::watch;
+use tokio_util::sync::CancellationToken;
+use tracing as log;
+
+#[derive(Builder)]
+pub struct KvRoutedIngress {
+    #[builder(setter(into))]
+    pub service_name: String,
+
+    #[builder(setter(into))]
+    pub worker_id: String,
+
+    pub nats: nats::Client,
+    pub service_handler: Arc<dyn PushWorkHandler>,
+    pub metrics_rx: watch::Receiver<Arc<ForwardPassMetrics>>,
+    pub cancellation_token: CancellationToken,
+}
+
+/// version of crate
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+impl KvRoutedIngress {
+    pub fn builder() -> KvRoutedIngressBuilder {
+        KvRoutedIngressBuilder::default()
+    }
+
+    pub async fn start(self) -> Result<()> {
+        let worker_id = self.worker_id;
+
+        log::trace!(
+            worker_id,
+            "Starting nats service: {}:{}",
+            self.service_name,
+            VERSION
+        );
+
+        let mut metrics_rx = self.metrics_rx;
+        let worker_id_clone = worker_id.clone();
+
+        let service = self
+            .nats
+            .client()
+            .service_builder()
+            .description("A handy min max service")
+            .stats_handler(move |name, stats| {
+                log::debug!(
+                    worker_id = worker_id_clone.as_str(),
+                    "[IN worker?] Stats for service {}: {:?}",
+                    name,
+                    stats
+                );
+                let metrics = metrics_rx.borrow_and_update().clone();
+                serde_json::to_value(&*metrics).unwrap()
+            })
+            .start(self.service_name.as_str(), VERSION)
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to start service: {e}"))?;
+
+        let group = service.group(self.service_name.as_str());
+
+        log::trace!(worker_id, "Starting endpoint: {}", worker_id);
+
+        // creates an endpoint for the service
+        let service_endpoint = group
+            .endpoint(worker_id.clone())
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to start endpoint: {e}"))?;
+
+        let push_endpoint = PushEndpoint::builder()
+            .service_handler(self.service_handler)
+            .cancellation_token(self.cancellation_token)
+            .build()
+            .map_err(|e| anyhow::anyhow!("Failed to build push endpoint: {e}"))?;
+
+        push_endpoint.start(service_endpoint).await
+    }
+}

llm/rust/triton-llm/src/lib.rs

@@ -18,7 +18,8 @@
 //! The `triton-llm` crate is a Rust library that provides a set of traits and types for building
 //! distributed LLM inference solutions.
 
+pub mod engines;
 pub mod http;
+pub mod kv_router;
 pub mod protocols;
 pub mod types;
-pub mod engines;

pyproject.toml

@@ -61,8 +61,8 @@ addopts = [
     "--ignore-glob=*model.py",
     # FIXME: Get relative/generic blob paths to work here
     # Ignore rust<->python bindings until python package is built/installed in environment
-    "--ignore-glob=/workspace/runtime/rust/python-wheel/python/triton_distributed_rs/*.py",
-    "--ignore-glob=/workspace/runtime/rust/python-wheel/python/triton_distributed_rs/*.pyi",
+    "--ignore-glob=/workspace/python-wheel/python/triton_distributed_rs/*.py",
+    "--ignore-glob=/workspace/python-wheel/python/triton_distributed_rs/*.pyi",
 ]
 xfail_strict = true
 log_cli_level = "INFO"