Browse Documentation
Foundation
Platform
Capabilities
Product
Core Platform
Core Platform
Developers
Operations
Business
Billing and Plans
Billing and Plans
The SDK family is a runtime map: wrappers for lifecycle owners, direct clients for transport owners, and dedicated operator lanes.
This page reflects the actual monorepo inventory rather than a simplified brochure list. The direct runtime client, 16 JavaScript wrappers, three native language SDKs, and the CLI/MCP operator surfaces all have different jobs.
core client
1
@cosantoir/node
JS wrappers
16
Framework and server packages
language SDKs
2
Go, Rust, Python
operator lanes
2
CLI and MCP
Top-level inventory
Package inventory
Every package exists because it owns a different slice of runtime logic. Treating them as interchangeable is how docs and code drift apart.
Direct runtime
@cosantoir/node
Direct evaluator client for custom servers, bespoke middleware order, and exact transport control.
Operator surface
@cosantoir/cli
Terminal lane for login, request probes, and telemetry-backed operator workflows.
Operator surface
@cosantoir/mcp
Model-facing tool server for safe policy and evaluator access.
JavaScript wrapper family
Adapter family
The wrapper family splits into app-level and server-level ownership. That distinction matters more than language aesthetics.
App wrappers
Packages for frameworks that already own route resolution, middleware chains, or loaders.
Next.js
@cosantoir/next
Proxy and route-handler protection for App Router and middleware-heavy request paths.
Astro
@cosantoir/astro
SSR middleware entry point for Astro request handling.
Nuxt
@cosantoir/nuxt
Server middleware surface for Nuxt application routes.
SvelteKit
@cosantoir/sveltekit
Hook-based enforcement for SvelteKit routes and endpoints.
SolidStart
@cosantoir/solid-start
Middleware surface for SolidStart request handling.
Remix
@cosantoir/remix
Loader and action control for Remix applications.
React Router
@cosantoir/react-router
Data-router protection for route loaders and actions.
Server wrappers
Packages for servers where hooks, handlers, or fetch semantics are the integration boundary.
Express
@cosantoir/express
Middleware enforcement for existing Node API servers.
Hono
@cosantoir/hono
Fetch-native protection for edge and lightweight runtimes.
Fastify
@cosantoir/fastify
Fast pre-handler hooks for high-throughput APIs.
Koa
@cosantoir/koa
Async middleware protection inside Koa request chains.
Elysia
@cosantoir/elysia
Plugin entry point for Bun-native Elysia services.
AdonisJS
@cosantoir/adonisjs
HTTP middleware integration for AdonisJS applications.
NestJS
@cosantoir/nestjs
Guard and interceptor-oriented protection inside Nest applications.
Bun
@cosantoir/bun
Fetch-style request protection for Bun.serve runtimes.
Deno
@cosantoir/deno
Direct request handling for Deno services using npm imports.
Core constructor
Direct JavaScript client
01import { createCosantoir } from "@cosantoir/node";02 03const client = createCosantoir({04 baseUrl: process.env.COSANTOIR_GATEWAY_URL!,05 apiKey: process.env.COSANTOIR_API_KEY!,06 siteId: process.env.COSANTOIR_SITE_ID!,07});Native clients
Language constructor map
01Go cosantoir.NewClient(cosantoir.Options{ BaseURL, APIKey, SiteID })02Rust Cosantoir::new(CosantoirOptions { base_url, api_key, site_id, timeout_ms })03Python Cosantoir(CosantoirOptions(base_url=..., api_key=..., site_id=...))Native SDKs
Language clients
Go, Rust, and Python already exist as first-class repo surfaces. They should be documented as deliberate integration lanes, not afterthoughts.
Go
github.com/cosantoir/cosantoir-go
Typed client with `NewClient`, `EvaluateWAF`, and `EvaluateBot` for Go services.
Rust
cosantoir
Async client surface with `Cosantoir::new` and `evaluate_waf`.
Python
cosantoir
Direct evaluator client with `waf_evaluate`, `bot_evaluate`, and `ip_lookup`.
Python + Flask
cosantoir
Direct evaluator client inside Flask `before_request` hooks and route handlers.
Surface choice
Selection rules
Choosing the wrong surface is how the code and docs both become vague. Pick by lifecycle ownership.
Use a wrapper when the framework owns request state.
If middleware, route handlers, hooks, or loaders are the real boundary, the wrapper should be the first-class surface.
Use `@cosantoir/node` when you own transport and response shape.
Direct evaluator calls are cleaner when your code decides method, path normalization, timing, or fan-out behavior.
Use language SDKs outside the JavaScript ecosystem.
Go, Rust, and Python are not fallback lanes; they are the right surface for services that already live there.
Use CLI and MCP for operator and agent work only.
They should not replace request middleware. They exist to observe, bootstrap, and expose bounded evaluator access.
Coverage map
Coverage map
Use the coverage count to judge breadth, but use the surface map to judge where each package belongs.
App wrappers
7
Server wrappers
9
Language clients
4
Operator surfaces
2