Crate rskit 

rskit — production Rust toolkit.

This crate is a pure facade that re-exports rskit-* sub-crates from a single namespace. It contains no implementation logic.

Always-on foundation crates:

Module	Extra crate
util	rskit-util (domain-free foundation utilities)
errors	rskit-errors (error types and result aliases)
fs	rskit-fs (local filesystem primitives)
config	rskit-config (adapter-oriented config loading)
logging	rskit-logging (tracing subscriber setup)
resilience	rskit-resilience (retry, timeout, circuit breaker)
provider	rskit-provider (provider traits and tower bridge)
stream	rskit-stream (broadcaster, sources, tasks, stream operators)
bootstrap	rskit-bootstrap (app lifecycle orchestration)
component	rskit-component (component lifecycle primitives)
worker	rskit-worker (worker pools and typed events)
validation	rskit-validation (field-level validation)

Optional feature flags control higher-level modules and adapters:

Feature	Extra crate
server	rskit-server (service-facing server abstractions)
grpc	rskit-grpc (aligned gRPC client/server transport)
encryption	rskit-encryption (encryption helpers)
http	rskit-http (framework-neutral HTTP abstractions)
httpclient	rskit-httpclient (bounded HTTP client)
auth	rskit-auth (JWT, OIDC, password)
auth-jwt	JWT support in rskit-auth
auth-oidc	OIDC support in rskit-auth
di	rskit-di (dependency injection)
database	rskit-database (core + memory backend)
database-sqlite	SQLite database backend
cache	rskit-cache (core + memory adapter)
cache-fs	Filesystem cache adapter in rskit-cache
cache-redis	Redis cache adapter
messaging	rskit-messaging (core abstractions + in-memory backend)
messaging-kafka	Kafka messaging adapter
messaging-nats	NATS messaging adapter
messaging-rabbitmq	RabbitMQ messaging adapter
vectorstore	rskit-vectorstore (core + memory backend)
vectorstore-qdrant	Qdrant vector store adapter
observability	rskit-observability (OpenTelemetry)
authz	rskit-authz (RBAC/ABAC)
security	rskit-security (TLS/security configuration)
discovery	rskit-discovery (service discovery)
sse	rskit-sse (Server-Sent Events)
dag	rskit-dag (DAG orchestration)
chain	rskit-chain (sequential execution)
process	rskit-process (subprocess execution)
fs-watch	Recursive filesystem change watching (rskit-fs::watch, FsWatcher)
stateful	rskit-stateful (stateful accumulators)
version	rskit-version (build metadata)
schema	rskit-schema (JSON Schema generation/validation)
hook	rskit-hook (typed event hooks)
genai	rskit-ai (shared GenAI vocabulary)
llm	rskit-llm (LLM providers)
llm-openai	OpenAI LLM adapter
llm-anthropic	Anthropic LLM adapter
llm-ollama	Ollama LLM adapter
llm-gemini	Gemini LLM adapter
embedding	rskit-embedding (embedding abstractions)
inference	rskit-inference (model-serving abstractions)
inference-triton	Triton inference adapter
inference-vllm	vLLM inference adapter
inference-tgi	Hugging Face TGI inference adapter
prompt	Prompt schema helpers from rskit-ai
skill	rskit-skill (skill manifests and registries)
tool	rskit-tool (tool contracts)
agent	rskit-agent (agentic turn-loop engine)
mcp	rskit-mcp (tool registry to Model Context Protocol bridge)
storage	rskit-storage (File I/O, storage)
media	rskit-media (media types, pipeline)
media-ffmpeg	rskit-media-ffmpeg (FFmpeg backend)
media-image	rskit-media-image (image processing)
media-audio	rskit-media-audio (pure Rust audio analysis)
media-full	FFmpeg + image + audio backends
storage-s3	S3 storage backend
storage-gcs	GCS storage backend
storage-supabase	Supabase storage backend
cli	rskit-cli (CLI helpers)
git	rskit-git (Git automation)
dataset	rskit-dataset (dataset collection)
bench	rskit-bench (ML benchmarking)
workload	rskit-workload (workload orchestration)
full	all features

Test helpers live in rskit-testutil and should be added directly as a dev-dependency; they are intentionally not part of this production facade.

Quick start

[dependencies]
rskit-suite = { version = "0.2.0-alpha.2", features = ["full"] }

Or enable only the optional modules you need — for example recursive, debounced filesystem-tree change watching:

[dependencies]
rskit-suite = { version = "0.2.0-alpha.2", features = ["fs-watch"] }

Re-exports

pub use rskit_util as util;

pub use rskit_errors as errors;

pub use rskit_fs as fs;

pub use rskit_config as config;

pub use rskit_logging as logging;

pub use rskit_resilience as resilience;

pub use rskit_provider as provider;

pub use rskit_stream as stream;

pub use rskit_bootstrap as bootstrap;

pub use rskit_component as component;

pub use rskit_worker as worker;

pub use rskit_validation as validation;

pub use rskit_chain as chain;

pub use rskit_process as process;

pub use rskit_stateful as stateful;

pub use rskit_version as version;

pub use rskit_schema as schema;

pub use rskit_hook as hook;

pub use rskit_server as server;

pub use rskit_grpc as grpc;

pub use rskit_encryption as encryption;

pub use rskit_http as http;

pub use rskit_httpclient as httpclient;

pub use rskit_auth as auth;

pub use rskit_di as di;

pub use rskit_database as database;

pub use rskit_database_sqlite as database_sqlite;

pub use rskit_cache as cache;

pub use rskit_cache_redis as cache_redis;

pub use rskit_messaging as messaging;

pub use rskit_messaging_kafka as messaging_kafka;

pub use rskit_messaging_nats as messaging_nats;

pub use rskit_messaging_rabbitmq as messaging_rabbitmq;

pub use rskit_observability as observability;

pub use rskit_authz as authz;

pub use rskit_security as security;

pub use rskit_discovery as discovery;

pub use rskit_sse as sse;

pub use rskit_dag as dag;

pub use rskit_ai as genai;

pub use rskit_llm as llm;

pub use rskit_llm_openai as llm_openai;

pub use rskit_llm_anthropic as llm_anthropic;

pub use rskit_llm_ollama as llm_ollama;

pub use rskit_llm_gemini as llm_gemini;

pub use rskit_embedding as embedding;

pub use rskit_inference as inference;

pub use rskit_inference_triton as inference_triton;

pub use rskit_inference_vllm as inference_vllm;

pub use rskit_inference_tgi as inference_tgi;

pub use rskit_skill as skill;

pub use rskit_tool as tool;

pub use rskit_agent as agent;

pub use rskit_mcp as mcp;

pub use rskit_storage as storage;

pub use rskit_storage_s3 as storage_s3;

pub use rskit_storage_gcs as storage_gcs;

pub use rskit_storage_supabase as storage_supabase;

pub use rskit_vectorstore as vectorstore;

pub use rskit_vectorstore_qdrant as vectorstore_qdrant;

pub use rskit_media as media;

pub use rskit_media_ffmpeg as media_ffmpeg;

pub use rskit_media_image as media_image;

pub use rskit_media_audio as media_audio;

pub use rskit_cli as cli;

pub use rskit_git as git;

pub use rskit_dataset as dataset;

pub use rskit_bench as bench;

pub use rskit_workload as workload;

Modules

prompt

Prompt templates and output schema contracts. Prompt templates, registries, and renderers. Prompt templates, registries, and render helpers.

Structs

App

Application orchestrator with typestate lifecycle.

AppBuilder

Builder for App.

AppError

Application-level structured error.

CircuitBreaker

Asynchronous circuit breaker.

ConfigLoader

Loads typed configuration from ordered source adapters.

Health

Health report from a single component.

LazyComponent

Wraps a component factory so construction is deferred until start().

LoggingGuard

Opaque guard — drop to restore the previous tracing subscriber.

Pool

A bounded async worker pool.

PoolConfig

Configuration for a Pool.

RateLimiter

Token-bucket rate limiter backed by governor.

Registry

Ordered component registry.

RegistryConfig

Configuration for the component registry.

RetryPolicy

Retry policy with configurable backoff and retry predicate.

ServiceConfig

Base service configuration — embed this in every application config.

StopResult

Detailed result for an attempted component stop.

TaskHandle

Handle returned to a caller after submitting a task to the pool.

Enums

ErrorCode

Machine-readable error code.

HealthStatus

Liveness state of a component.

State

Lifecycle state tracked for each registered component.

Traits

AppConfig

Trait that every application config struct must implement.

Component

Lifecycle-managed infrastructure component.

Handler

Core trait for worker task handlers.

Provider

Stable identity for a provider.

RequestResponse

Unary request → single response (HTTP POST, gRPC unary, DB query).

Sink

Write-only (Kafka publish, webhook, S3 put, log sink).

Functions

init_logging

Initialize structured logging from a LoggingConfig with default masking.

init_logging_env

Initialize logging from RUST_LOG only (no config struct needed).

Type Aliases

AppResult

Convenience alias used throughout rskit crates.