Jev SDK

Vercel's agent framework with Jev wired into its experimental evaluate path, so the scoring step of an agent returns typed decisions rather than prose the surrounding code has to parse.

A Python decorator that turns a Pydantic model into Jev questions: bool becomes a Noul, a Literal becomes a Choice, and a bounded int becomes a Score, with answers validated back into the model.

Vercel's official AI SDK for Python, in public beta: streaming models, agent tool loops, hooks for human approval and structured output, with provider IDs routing through AI Gateway by default. The SDK's evaluation operation and Gateway examples carry Jev as a decision and evaluation provider.

Self-hosted Python SDK and System One-compatible API for runtime-defined Choice, Boolean and Score decisions on pinned open models, across Torch, vLLM, MLX, llama.cpp and WebGPU. Each result records probabilities, token usage, timing, model revision and prompt version, with committed row-level benchmarks.

Unofficial portable Clojure SDK for TypeSafe System One. It posts state and typed questions to /v1/systemone, lists available models, and returns validated Clojure data with keyword or string answer keys, on a JVM backend or a native Jolt backend.

Dependency-free Go 1.24+ client for Jev Noul, Choice, and Score questions: ChoiceOf[T] and ScoreOf[L] return the caller's own types and reject labels the question never offered, with validation before sending, retries that honor Retry-After, OpenRouter support, and eleven tested examples.

Ruby gem that makes System One measurement a language primitive: psi prepares a state, judge/choose/score return calibrated distributions, and ? collapses them for control flow. Ships TypeSafe, protocol (/v1/systemone) and CUA providers behind one interface with its own spec suite.

A community tutorial site that walks from Jev concepts to a first API call, the Python SDK, Choice/Score/Noul question types, and confidence thresholds. It also hosts a project radar of community repositories with E0-E3 evidence levels and review boundaries for each listing.

Release notes for the official Python SDK, from the 14 September 2026 public release through the Pydantic migration and the HTTP/2 extra.

Release notes for the official JavaScript and TypeScript SDK: the 11 September 2026 public release and the Score criteria breaking change.

RetryPolicy for the Python SDK: attempt count, exponential backoff with jitter, which HTTP statuses retry, and a total time budget.

The Python SDK error hierarchy: HTTP status classes, rate-limit wait hints, connection and timeout errors, and response-body validation failures.

AsyncTypeSafeClient: async system_one calls, model listing, per-call retry and timeout overrides, and an optional Pydantic response model.

How the Python SDK types questions: Noul, Choice, and Score as objects or dictionaries, including optional JSON instructions and criteria.

The Python response models: SystemOneResponse groups answers by id, and records the model name, token usage, and request id.

Default settings and environment variable names for the Python SDK, including the API root, model alias, and per-request timeout.

TypeSafeClient, the synchronous Python client: ask questions, list models, and set the key, model, retry policy, and HTTP timeout.

Shared Python SDK types: JSONValue, a nested JSON-like value that may be None, and descriptions built from strings or JSON values.

OpenRouter's guide for calling Jev with the official JavaScript or Python SDK by changing the base URL and using an OpenRouter key.

Rust docs for typesafe-jev 0.2.0, a blocking client that sends one state and a set of Choice, Score, and Noul questions and prices input tokens at list rate.

The generated API reference for the official JavaScript SDK, listing every exported class, interface, function, and type.

The generated API reference for the official Python SDK, split into sync and async clients, question and response types, retries, exceptions, and constants.

The full usage guide for the Python SDK, covering typed calls, model selection, retries, error handling, logging, environment variables, and forward compatibility.

A browser builder for System One requests: define state plus Noul, Choice, and Score questions, preview mock distributions, and generate Python typesafe_sdk code.

A TypeScript tutorial and critical explainer covering AI SDK integration, triage code, and the zero-hallucination caveat.

The docs site for an unofficial Go client that wraps /v1/systemone and /v1/models with typed question and answer types.

.NET SDK for the System One API with typed question sets, HttpClientFactory and dependency-injection wiring, plus Microsoft.Extensions.AI guardrail, routing, tool, and evaluator adapters.

A NativeAOT-ready .NET SDK generated from TypeSafe's OpenAPI definition, with typed question sets, batching, dependency injection, and Microsoft.Extensions.AI integrations.

A small Go client for the System One API with typed Noul, Choice, and Score question structs, developed independently of the official Python and TypeScript SDKs.

A DSPy fork whose @typesafeify decorator routes decision-shaped signature fields to Jev, so bool, Literal, and scored outputs come back typed while freeform fields still use the LM.

A hand-written Go client for the System One API, built against the vendored OpenAPI 3.1 specification with no third-party dependencies and typed Noul, Choice, and Score questions.

A community Rust port of the official Python SDK with the same primitives, wire format, retries, and error semantics, plus derive macros for typed questions and answers.

An unofficial, dependency-free Go SDK for the System One API that uses only the standard library, validates question limits client-side, and retries rate limits and server errors.

Unofficial LlamaIndex reranker and router built on the official Python SDK: JevRerank scores retrieved passages and JevSingleSelector chooses which tool handles a query.

An Elixir client that treats Jev as a peer GenServer: you reply with questions and its typed answers arrive as messages you pattern-match, with network-free tests.

A TypeScript library that walks a taxonomy and calls Jev once per level, so a choice can cover thousands of leaves despite Jev's 255-option limit per question.

An unofficial Laravel integration for the PHP TypeSafe SDK that keeps typed DTOs and promises while adding package discovery, scoped lazy DI, config, a facade, and a recording fake.

A Scala 3 and ZIO HTTP client for TypeSafe's Jev System One API: ask typed Noul, Choice, and Score questions in one round-trip via a NamedTuple and get answers shaped exactly like the questions.

An async LangGraph workflow that sends a mocked email to Jev, receives a typed Choice between invoice and general, and routes it to a demo handler, with confidence and both label probabilities printed for inspection.

An Elixir SDK for TypeSafe AI and Jev with typed Choice, Score, and Noul structs, retries, batching, and OTP integration; version 0.4.1 is the final release of this package line.

An unofficial, dependency-free Go SDK for Jev's System One API with direct TypeSafe and Vercel AI Gateway providers, an interactive CLI, and an installable agent skill that covers request and retry semantics.

A Ruby client for TypeSafe's System One API that returns typed Noul, Choice, and Score answers, validates obvious input mistakes before spending a request, and pools HTTP connections across threads.

An Apache-licensed System One decision server that reads Choice, Score, and Noul probabilities from DiffusionGemma 26B-A4B through vLLM on NVIDIA or MLX on Apple silicon, so TypeSafe SDKs work unchanged.

A server that implements the TypeSafe/Jev HTTP API with Qwen3.6-35B-A3B on SGLang 0.5.19, deployed on Modal with radix caching and breakable prefill CUDA graphs, plus a separate FastAPI process.

A Ruby client for Noul, Choice, and Score decision models, reaching OpenRouter by default or TypeSafe's native API, with no runtime dependencies beyond the standard library.

A Rust client for the System One API with typed Noul, Choice, and Score results, async and blocking transports, batched questions over one state, and inspectable retry and error details.

An independent Rust client for the System One API targeting parity with the official Python and JavaScript SDKs at 0.6.0, with async and blocking clients, model discovery, and configurable retries.

An async Python client for Jev with typed Noul, Choice, and Score helpers: questions batch into one request, and callers get probabilities, choices, and weighted scores instead of text to parse.

A RubyLLM 2 provider that adds Jev through structured output: build Noul, Choice, and Score questions with a schema builder, pass them to chat.with_schema, and read typed answers from response.parsed.

A community Rails integration built on the typesafe-sdk Ruby gem that adds Rails configuration, persisted usage and cost telemetry, and persistence-backed confidence policies for Choice and Score answers.

A community Rust client for Jev's System One API whose environment variables, defaults, retries, identification headers, and error kinds match the official Python and TypeScript SDKs.

A filesystem-first framework for durable AI agents whose auto model router defaults to Jev through Vercel AI Gateway and whose evaluate helper asks typed Choice, Score, and Boolean questions inside tools.

A local server and Python package that runs open models with Hugging Face Transformers or PyTorch and returns Choice, Score, and Noul answers read from next-token logits instead of generated JSON.

A Pi extension and library that gives the agent and other extensions one consented, key-managed Jev client, with a batched typesafe_evaluate tool for classify, triage, compare, and score judgments.

A Rust derive layer for typed System One decisions: enums and structs become Choice, Score, and Noul questions with compile-time-checked, confidence-gated answers, plus a scriptable fake client for network-free tests.

A dependency-free Swift 6 client for the TypeSafe AI System One API, ported from the official JavaScript and Python SDKs, with Choice, Score, and Noul questions, strict concurrency, and configurable retries.

An unofficial bilingual index of applications, clients, tools, and research built with Jev, spanning official resources, community SDKs in many languages, demos and games, and articles.

A community field guide to TypeSafe's Jev with one documented support-ticket call, runnable JavaScript and Python starters, a JSON directory, and links to independent evaluations.

Community Java 17 client for TypeSafe's System One API with typed Noul, Choice and Score questions, lambda-style builders for nested criteria, status-specific exceptions and a Spring Boot starter.

Unofficial Swift 6.4 client for TypeSafe's System One API, following the Python SDK 0.7.0 API with @QuestionSet property wrappers for typed Noul, Choice and Score questions.

A MoonBit playground for TypeSafe's Jev: a client for GET /v1/models and POST /v1/systemone with noul, choice, and score questions, a single-query CLI, a Jev-vs-Jev gomoku game, and a tool that replays game logs as real-time GIFs.

A Juspay TypeScript SDK that treats Jev as a third inference type beside generate and stream: providers declare which kinds they serve, and tryDecide returns typed boolean, choice, or score answers, null when no decision provider is set.

An unofficial PHP client for the TypeSafe AI System One API with typed Noul, Choice, and Score responses, synchronous and Guzzle-promise calls, model discovery, retries, and PSR-3 logging.

A lightweight, pluggable Java framework for CLI, HTTP, and modular applications that carries Jev, TypeSafe, and MCP-server topics; added from Maven as org.tinystruct:tinystruct and requiring JDK 17 or higher.

An async Scala client for the OpenAI API and multiple providers, with a dedicated TypeSafe AI adapter that answers Jev System One typed questions alongside Anthropic, Gemini, Groq, and Perplexity support.

A source-backed directory of 157 open-source projects built with Jev whose submissions are reviewed by the Jev Review Action, which checks source evidence and suggests a category while maintainers decide merges.

The official SDK hub: Python and JavaScript/TypeScript clients with typed questions and answers plus automatic retries, and the HTTP API for every other language.

Quickstart for @typesafe-ai/sdk on Node 20+: answer types inferred from your questions, a choice() helper, and one systemOne call to classify a support ticket.

Usage guide for typesafe-sdk: sync and async clients, uv and pip installs, and one request mixing Noul, Choice, and Score questions with answers grouped by type.

A small TypeScript client for asking typed questions about your data: one ask call mixes yes/no, choice, and score questions and returns probabilities, selected options, and confidences.

An unofficial Go client for the System One API: typed judgments and calibrated probabilities instead of generated text.

Community .NET SDK for the System One API: typed noul, choice, and score questions with structured, confidence-scored answers.

A community PHP and Laravel SDK for the Jev model series, wrapping typed questions and probability answers for the PHP ecosystem.

Official TypeScript/JavaScript client with inferred answer types, retries, and a question DSL. `npm install @typesafe-ai/sdk`.

Official sync and async Python client for the TypeSafe API with typed questions, retry policies, and inferred answers. `pip install typesafe-sdk`.