API reference

Install

Zero runtime, optional or peer dependencies — including the Vercel provider. Uses native fetch. Requires Node.js 22+ and ESM; keep credentials on your server.

npm install sysone-help

# Set AI_GATEWAY_API_KEY in your server environment

import { createSysone } from "sysone-help";
import { vercel } from "sysone-help/providers/vercel";

const sys = createSysone({
  provider: vercel(),
  model: "typesafe-ai/jev",
});
const result = await sys.check(
  "Can you send the proposal?", "Does this message need a reply?",
);
console.log(result.decision, result.probability);
// { decision: "yes" | "no" | "uncertain", probability, metadata }

node demo.mjs

Save the example as demo.mjs after setting your provider key. This uses your own account; the playground above uses the shared account. Examples default to Jev through Vercel AI Gateway. Current Jev pricing ↗

Small by design

No SDK, schema library, polyfill or third-party code is installed or bundled into Sysone. Providers are separate ESM entry points; import the ones you use. TypeScript declarations are included.

Version 0.5.1. All core exports retained, esbuild 0.28.2, ESM/ES2022, gzip level 9 (zlib 1.3.1.zlib-ng). Compression versions may differ slightly. These are JavaScript bundle sizes, not package download size or this website's size. Types and docs are excluded. CI enforces a 4,000-byte gzip budget for the complete bundle.

Reproduce with npm run build && npm run size ↗

Which function do I need?

check

One yes/no question. Returns a decision, probability and metadata.

evaluate

Several questions about one input. Typed labels, scores and raw probabilities in one request.

partition

Split a list into yes, no and uncertain. Keep the original items.

filter

Keep only yes items. Use partition if uncertain items need review.

rank

Order a list by a descriptive rubric. Highest score first.

check returns an object, not a boolean. Read its decision explicitly:

const result = await sys.check(message, "Needs a reply?");
if (result.decision === "yes") {
  console.log("Take the yes branch");
}
// Treat "no" and "uncertain" according to your application's policy.
// Network errors throw; they are not an "uncertain" answer.

Definitions and evaluation

Definitions are immutable data. Creating them is local and free. evaluate asks multiple independent questions about the same input in one request.

import { predicate, classifier } from "sysone-help";

const needsReply = predicate("Does this need a reply?");
const team = classifier({
  billing: "Payments, invoices and refunds",
  support: "Bugs and technical questions",
  other: "Everything else",
});

const { answers } = await sys.evaluate(message, { needsReply, team });
answers.team.choice; // "billing" | "support" | "other"
answers.needsReply.probability; // number, from 0 to 1

Each question sees the input, not the answers to the other questions. Raw evaluation returns evidence; check applies a yes/no threshold.

Collections

const groups = await sys.partition(messages, needsReply, {
  select: message => message.body,
  minProbability: 0.85,
  concurrency: 4,
});

groups.yes;       // Keep the original objects
groups.no;        // Preserve their original order
groups.uncertain; // Review these separately

// Only need the yes group? filter uses the same policy.
const actionable = await sys.filter(messages, needsReply, {
  select: message => message.body,
});

For ranking, define a rubric rather than an unexplained score:

import { rubric } from "sysone-help";

const urgency = rubric("How urgent is this request?", [
  "Routine: no time pressure",
  "Soon: time-sensitive but not blocking",
  "Immediate: active outage or severe disruption",
]);

const ranked = await sys.rank(messages, urgency, {
  select: message => message.body,
});
// [{ item, score, answer, metadata }] — highest score first

Collections make one request per item. Ranking scores each item independently against the same rubric. Equal scores keep input order.

Providers and models

A provider configures credentials, transport and endpoint. A model selects what runs through it. The same provider can serve multiple evaluation models; choose a model explicitly.

import { createSysone } from "sysone-help";
import { vercel } from "sysone-help/providers/vercel";
import { typesafe } from "sysone-help/providers/typesafe";

const gateway = vercel(); // Connection and credentials.

const sys = createSysone({
  provider: gateway,
  model: "typesafe-ai/jev", // Selection within the provider's catalog.
});

// The same Jev family, through its native provider:
const direct = createSysone({
  provider: typesafe(),
  model: "jev-latest",
});

Reuse gateway with another model ID to create another client. IDs belong to the provider's evaluation catalog; Sysone does not assume that providers share aliases or that every model supports evaluation. There is no default model or silent fallback.

Cloudflare and OpenRouter also offer access to Jev; their Sysone adapters are not included in this release. A custom integration implements the exported EvaluationProvider interface.

The Vercel adapter calls the Gateway evaluation protocol directly using native fetch. The protocol is experimental; no SDK or additional package is required. Confidence and probabilities may differ across models; thresholds need evaluation on your own examples. Gateway extensions remain namespaced in metadata.providerMetadata, without assuming TypeSafe semantics.

import { createSysone, predicate } from "sysone-help";
import { customProvider } from "sysone-help/providers/custom";

const sys = createSysone({
  provider: customProvider({
    baseURL: "http://127.0.0.1:8080/v1",
    id: "local",
  }),
  model: "openjev-latest",
});

await sys.check("Can you help?", predicate("Needs a reply?"));

Use customProvider for your own endpoint, regardless of the model’s license. An open model offered through Vercel still uses vercel(). Start your OpenJev server first. This provider currently supports the System One HTTP protocol and appends /systemone to the API base. Optional apiKey and headers support authenticated servers. This code runs in your app; the shared playground always uses Jev.

Models & open alternatives

Sysone works with evaluation models. Jev powers this shared playground; it is one implementation, not a requirement of the library.

Reviewed September 19, 2026. An open implementation is not Jev's weights. Matching request shapes does not mean matching quality or calibration. OpenJev derives confidence from normalized entropy; validate thresholds again when switching models.

Real inference results and runnable checks ↗

Research notes, licenses and compatibility details ↗

Execution behavior

Uncertainty

check defaults to 80%. filter excludes uncertain items; partition keeps them available.

Cancellation

Pass { signal: controller.signal } to an operation. The default per-request timeout is 30 seconds.

Retries

No automatic retries or provider fallback. A failed collection rejects; already running requests may finish and incur usage.

Evidence

Provider confidence is separate from answer probability. Missing evidence stays missing. Invalid responses throw SysoneError.

Input

Text or JSON objects/arrays. Jev evaluates the supplied context; it does not browse, generate explanations, or execute actions.