AWESOME
JEV

questions: {
  direction: choice,
}

questions: {
  requested: boolean,
  issued: boolean,
  route: choice,
  // +1
}

questions: {
  intent: choice,
  is_urgent: boolean,
  frustration: score,
}

questions: {
  department: choice,
  return_reason: choice,
  requested_resolution: choice,
  // +2
}

questions: {
  correctness: boolean,
  security: boolean,
  reliability: boolean,
  // +2
}

questions: {
  action: choice,
  done: boolean,
  risk: boolean,
}

questions: {
  direction: choice,
}

questions: {
  requested: boolean,
  issued: boolean,
  route: choice,
  // +1
}

questions: {
  intent: choice,
  is_urgent: boolean,
  frustration: score,
}

questions: {
  department: choice,
  return_reason: choice,
  requested_resolution: choice,
  // +2
}

questions: {
  correctness: boolean,
  security: boolean,
  reliability: boolean,
  // +2
}

questions: {
  action: choice,
  done: boolean,
  risk: boolean,
}

questions: {
  refund: boolean,
  spam: boolean,
}

questions: {
  next_action: boolean,
  danger: score,
}

questions: {
  window: choice,
  source_reddit: boolean,
  plain: boolean,
}

questions: {
  positive: boolean,
}

questions: {
  billing: boolean,
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  severity: score,
  needs_tool: boolean,
}

questions: {
  destructive: boolean,
  exfiltration: boolean,
  beyond_scope: boolean,
  // +1
}

questions: {
  urgency: score,
}

questions: {
  queue: choice,
  escalate: boolean,
  urgency: score,
  // +1
}

questions: {
  risk: score,
}

questions: {
  stale: choice,
}

questions: {
  intent: choice,
  needs_reasoning: score,
}

questions: {
  relevant: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  ok: boolean,
}

questions: {
  sentiment_spectrum: score,
  catalyst_impact: score,
}

questions: {
  refund: boolean,
}

questions: {
  department: choice,
  urgent: boolean,
  frustration: score,
}

questions: {
  intent: choice,
  reuse_cache: boolean,
  needs_subagent: boolean,
  // +2
}

questions: {
  refund: boolean,
  team: choice,
}

questions: {
  next_reference: choice,
}

questions: {
  problem: score,
  customer: score,
  demand: score,
  // +5
}

questions: {
  ok: boolean,
}

questions: {
  r0_missing: boolean,
  r0_instruction: boolean,
}

questions: {
  is_billing: boolean,
  category: choice,
}

questions: {
  stuck: boolean,
  destructive: boolean,
}

questions: {
  injection: boolean,
  hidden: boolean,
  exfiltration: boolean,
  // +3
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  questions: boolean,
}

questions: {
  binary: boolean,
  rating: score,
}

questions: {
  conflict: boolean,
}

questions: {
  s0: boolean,
  s1: boolean,
}

questions: {
  color: choice,
}

questions: {
  does_pass: boolean,
}

questions: {
  value: choice,
  surprising: boolean,
  funny: boolean,
  // +4
}

questions: {
  movement: choice,
  start_jump: boolean,
  ceiling_hop: boolean,
  // +1
}

questions: {
  action: choice,
  in_danger: boolean,
  threat: score,
}

questions: {
  amount_disclosed: boolean,
}

questions: {
  directed: boolean,
  kind: choice,
}

questions: {
  is_urgent: boolean,
  department: choice,
  frustration: score,
}

questions: {
  team: choice,
  human_requested: boolean,
  refund_requested: boolean,
  // +3
}

questions: {
  skill: choice,
}

questions: {
  route: choice,
}

questions: {
  noul: boolean,
}

questions: {
  lane_action: choice,
  speed_action: choice,
  hazard: score,
  // +1
}

questions: {
  route: choice,
  urgent: boolean,
  severity: score,
}

questions: {
  claims_done: boolean,
  claims_verified: boolean,
  verification_applies: boolean,
  // +1
}

questions: {
  route: choice,
  toolFree: boolean,
}

questions: {
  intent: boolean,
}

questions: {
  intent: choice,
  rage_bait: boolean,
  synthetic: boolean,
  // +1
}

questions: {
  actionable: boolean,
  priority: choice,
  value: score,
}

questions: {
  is_bug: boolean,
  team: choice,
  urgency: score,
}

questions: {
  topic: choice,
}

questions: {
  category: choice,
  urgency: score,
  isPersonal: boolean,
}

questions: {
  unambiguous_match: boolean,
}

questions: {
  call_t1: boolean,
}

questions: {
  intent: choice,
  isUrgent: boolean,
}

questions: {
  a: boolean,
  b: boolean,
}

questions: {
  billing: boolean,
  urgency: score,
}

questions: {
  context_needed: choice,
}

questions: {
  beauty: boolean,
  cat: choice,
}

questions: {
  irreversible: boolean,
  goal_done: boolean,
}

questions: {
  partial: boolean,
  score: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  category: choice,
  tech: boolean,
  ai_written: boolean,
}

questions: {
  q1: boolean,
}

questions: {
  is_spam: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  odd: boolean,
}

questions: {
  throttle: choice,
  yaw: choice,
  pitch: choice,
  // +3
}

questions: {
  unsolicited_promotion: boolean,
  profile_bait: boolean,
  scam_or_phishing: boolean,
  // +5
}

questions: {
  operation: choice,
}

questions: {
  about: boolean,
  keep: choice,
}

questions: {
  is_spam: boolean,
  folder: choice,
  suspicion: score,
}

questions: {
  connected: boolean,
}

questions: {
  operation: choice,
  click_target: choice,
  goal_reached: boolean,
  // +1
}

questions: {
  department: boolean,
  frustration: boolean,
}

questions: {
  delivery: boolean,
  department: choice,
  urgency: score,
}

questions: {
  done: boolean,
}

questions: {
  is_impossible: boolean,
}

questions: {
  is_urgent: boolean,
  frustration: score,
}

questions: {
  is_urgent: boolean,
}

questions: {
  routine: boolean,
}

questions: {
  automated: boolean,
}

questions: {
  done: boolean,
  blocked: boolean,
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  department: choice,
  frustration: score,
  is_urgent: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  what: choice,
}

questions: {
  t: boolean,
}

questions: {
  model: choice,
  effort: choice,
  is_followup: boolean,
}

questions: {
  needs_skill: boolean,
}

questions: {
  confidentiality: choice,
}

questions: {
  comparison: choice,
}

questions: {
  blocking: boolean,
}

questions: {
  department: choice,
}

questions: {
  content_type: choice,
}

questions: {
  is_command: boolean,
  complete: boolean,
}

questions: {
  department: choice,
  frustration: score,
  is_urgent: boolean,
}

questions: {
  requires_uncertainty_notice: boolean,
  response_depth: score,
}

questions: {
  verdict: choice,
  should: boolean,
  doom: score,
  // +1
}

questions: {
  difficulty: score,
  needs_reasoning: boolean,
  stakes: score,
  // +5
}

questions: {
  category: choice,
  reached_assertion: boolean,
  missing_context: boolean,
}

questions: {
  is_toxic: boolean,
  is_profane: boolean,
  severity: score,
  // +2
}

questions: {
  complexity: score,
  needsPlanning: boolean,
}

questions: {
  ping: boolean,
}

questions: {
  task_completion: score,
  instruction_following: boolean,
  grounded_in_evidence: boolean,
  // +5
}

questions: {
  is_billing: boolean,
}

questions: {
  complete: boolean,
}

questions: {
  wants_refund: boolean,
  intent: choice,
}

questions: {
  operation: choice,
}

questions: {
  destructive: boolean,
  exfiltration: boolean,
  privilege: boolean,
  // +4
}

questions: {
  enabled: boolean,
  color: choice,
  progress: score,
}

questions: {
  category: choice,
  bug_severity: score,
  has_repro_steps: boolean,
  // +2
}

questions: {
  action: choice,
}

questions: {
  content_type: choice,
  already_known: boolean,
  insight_density: score,
}

questions: {
  completion: choice,
}

questions: {
  relevant: boolean,
  category: choice,
}

questions: {
  hallucination_sensitive: boolean,
}

questions: {
  ping: boolean,
}

questions: {
  criteria: boolean,
}

questions: {
  claims_success: boolean,
}

questions: {
  label: choice,
}

questions: {
  irreversible: boolean,
}

questions: {
  composition: choice,
  legibility: boolean,
}

questions: {
  is_urgent: boolean,
  severity: score,
}

questions: {
  action: choice,
  asset: choice,
  condition_operator: choice,
}

questions: {
  tier: choice,
  is_greeting: boolean,
}

questions: {
  line: choice,
  pace: choice,
  overtake: boolean,
  // +1
}

questions: {
  severity: score,
  area: choice,
}

questions: {
  destructive: boolean,
  secrets: boolean,
}

questions: {
  is_exquisite_and_dynamic: boolean,
  animation_verdict: choice,
  primary_deficiency: choice,
}

questions: {
  person_name: boolean,
  email_or_phone: boolean,
  postal_address: boolean,
  // +5
}

questions: {
  is_regulation: boolean,
  mentions_deadline: boolean,
  mentions_fines: boolean,
  // +5
}

questions: {
  topic: choice,
  requests_credentials: boolean,
  sender_identity_mismatch: boolean,
  // +4
}

questions: {
  needs_rewrite: boolean,
  visual: choice,
}

questions: {
  states_application_instruction: boolean,
}

questions: {
  a: boolean,
  b: boolean,
}

questions: {
  is_urgent: boolean,
  department: choice,
}

questions: {
  file_removal: score,
  credential_theft: score,
  data_exfiltration: score,
  // +5
}

questions: {
  kind: choice,
  relationship: choice,
  review_priority: score,
}

questions: {
  uses: boolean,
}

questions: {
  ok: boolean,
}

questions: {
  alive: boolean,
}

questions: {
  urgent: boolean,
  severity: score,
}

questions: {
  outOfScope: boolean,
  contradictsPrevious: boolean,
  shouldFlag: boolean,
}

questions: {
  scope_alignment: score,
  touches_state: boolean,
  breaks_contracts: boolean,
  // +2
}

questions: {
  failure_domain: choice,
  customer_impact: score,
  systemic_outage: boolean,
}

questions: {
  succeeded: boolean,
}

questions: {
  action: choice,
  close_intent: boolean,
  intentional_control: boolean,
  // +1
}

questions: {
  edit: choice,
  contract: choice,
  caller: choice,
  // +2
}

questions: {
  next_move: choice,
}

questions: {
  same_intent: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  needs_vision: boolean,
  needs_tools: boolean,
}

questions: {
  eligible: boolean,
}

questions: {
  intent: choice,
  urgent: boolean,
  frustration: score,
}

questions: {
  disposition: choice,
  risk: score,
  data_exfil_risk: boolean,
  // +2
}

questions: {
  should_review: boolean,
  risk: choice,
  route: choice,
  // +1
}

questions: {
  fraud: choice,
}

questions: {
  is_project: boolean,
  substance: score,
}

questions: {
  impact: score,
}

questions: {
  q: boolean,
}

questions: {
  action: choice,
}

questions: {
  intent: choice,
  connection: choice,
  supported: boolean,
}

questions: {
  category: choice,
  bug_severity: score,
  wants_refund: boolean,
  // +1
}

questions: {
  is_urgent: boolean,
  needs_human: boolean,
  is_financial: boolean,
}

questions: {
  condition: choice,
}

questions: {
  q: boolean,
}

questions: {
  answered: boolean,
}

questions: {
  risky: boolean,
  submit_after_typing: boolean,
}

questions: {
  relevance: choice,
}

questions: {
  billing: boolean,
  urgent: boolean,
  team: choice,
  // +1
}

questions: {
  refund: boolean,
}

result = post_json("https://api.typesafe.ai/v1/systemone", os.environ["TYPESAFE_API_KEY"], body)

export const SYSTEM_ONE_URL = 'https://api.typesafe.ai/v1/systemone';

"adaptation": "Native Noul replaced with binary Yes/No Choice; state/question unchanged",

from typesafe_sdk import AsyncTypeSafeClient, RetryPolicy

const url = `${opts.baseUrl ?? 'https://api.typesafe.ai'}/v1/systemone`

url: 'https://api.typesafe.ai/v1/systemone',

--   jev.api_url            default 'https://api.typesafe.ai/v1/systemone' (proxies, mocks, tests)

import { choice, score } from "@typesafe-ai/sdk";

"jev (TypeSafe stepper)": ("typesafe_sdk", "quackd[jev]"),

typesafe: {endpoint:'https://api.typesafe.ai/v1/systemone',keyName:'TYPESAFE_API_KEY',model:'jev-latest',modelPattern:/^jev-[a-z0-9.-]{1,80}$/},

"/v1/systemone",

? "https://api.typesafe.ai/v1/systemone"

export const JEV_API_ENDPOINT = "https://api.typesafe.ai/v1/systemone";

export const DEFAULT_BASE_URL = "https://api.typesafe.ai";

"description": "Qwen3.5-0.8B-Base fine-tuned on frames labelled by ten per-game search programs to play ten browser games from 448 px screenshots, reading a pro

from typesafe_sdk import AsyncTypeSafeClient, Choice, Noul, Score

baseUrl = 'https://api.typesafe.ai/v1',

import { TypeSafeClient } from "@typesafe-ai/sdk";

parser = argparse.ArgumentParser(description="Local visual Choice/Noul/Score judgments")

"""Jev-compatible HTTP API: POST /v1/systemone and GET /v1/models.

export const TYPESAFE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";

? "> 💡 **如何快速复核**：如果项目中已接入 Jev / TypeSafe 决策机制（例如 Dart、Go、Rust、Java、Python、TS/JS 等多语言 SDK，或 OpenRouter decisions、`/v1/systemone` 调用），欢迎直接在本 Issue 中回复补充包含决策调用的*

@app.post("/v1/systemone", response_model=SystemOneResponse)

import { choice, noul, score } from "@typesafe-ai/sdk";

"name": "jev",

if r.URL.Path != "/v1/systemone" || r.Header.Get("Authorization") != "Bearer k" {

export const SYSTEM_ONE_URL = 'https://api.typesafe.ai/v1/systemone';

const res = await fetch("https://api.typesafe.ai/v1/systemone", {

typesafe: { host: "api.typesafe.ai" },

res = await fetch('https://api.typesafe.ai/v1/systemone', {

import { TypeSafeClient, choice, noul, type ChoiceCriteria, type EntryType } from "@typesafe-ai/sdk";

"jev": j_val,

"https://api.typesafe.ai/v1/systemone"

Jev takes a state plus a set of typed questions (Choice, Score, Noul) and returns typed answers with calibrated probabilities in one request, no text generation

apiBase: 'https://api.typesafe.ai',

return False, f"could not reach api.typesafe.ai ({e.__class__.__name__}); check your internet connection"

//! port, empty or root path only. Canonical origins append `/v1/systemone`

"""One small, strict client for TypeSafe Jev (POST /v1/systemone).

import { TypeSafeClient } from "@typesafe-ai/sdk";

v = sub.add_parser("serve", help="HTTP server with the model loaded once (POST /score, /v1/systemone)")

// Docs: https://docs.typesafe.ai/api  (POST /v1/systemone, Noul questions)

// mock-jev: a local stand-in for TypeSafe's `POST /v1/systemone`, for driving the router

ENDPOINT = "https://api.typesafe.ai/v1/systemone"

baseUrl: process.env.JEV_BASE_URL || 'https://api.typesafe.ai/v1/systemone',

import { createLiveTypeSafeClient, type TypeSafePort } from "../semantic/typesafe-client.js";

import { TypeSafeClient, type EntryType, type Questions } from "@typesafe-ai/sdk";

"name": "Jev",

from typesafe_sdk import AsyncTypeSafeClient, TypeSafeError

const res = await fetch(`${options.baseURL ?? 'https://api.typesafe.ai'}/v1/systemone`, {

ENDPOINT = 'https://api.typesafe.ai/v1/systemone'

url: "https://api.typesafe.ai/v1/systemone",

base_url: str = "https://api.typesafe.ai",

var request = URLRequest(url: URL(string: "https://api.typesafe.ai/v1/systemone")!)

ENDPOINT = "https://api.typesafe.ai/v1/systemone"

API_URL = "https://api.typesafe.ai/v1/systemone"

url, default_model, prefix = "https://api.typesafe.ai/v1/systemone", "jev-latest", "TYPESAFE"

const res = await fetch("https://api.typesafe.ai/v1/systemone", {

import { TypeSafeClient } from "@typesafe-ai/sdk";

Self::Typesafe => "https://api.typesafe.ai/v1/systemone",

"jev": j_val,

endpoint: "https://api.typesafe.ai/v1/systemone".into(),

return self.async_create_entry(title="Jev", data={CONF_API_KEY: api_key})

import { choice, TypeSafeClient, type Usage } from "@typesafe-ai/sdk";

base_url: str = "https://api.typesafe.ai",

const validUrl=url.protocol==='http:' && url.hostname==='127.0.0.1' && /^\d+$/.test(url.port) && url.pathname==='/v1/systemone' && !url.username && !url.passwor

self.http.get("https://api.typesafe.ai/v1/models")

"joshmn/typesafe-sdk": {

export const API_URL = process.env.JEV_API_URL || "https://api.typesafe.ai/v1/systemone";

# baseUrl: https://api.typesafe.ai

@app.post("/v1/systemone", response_model=DecisionResponse)

"text": "**Live Jev findings — 2026-09-18**\n\n89 live calls against `\nhttps://\napi.typesafe.ai/v1/systemone`, model `jev-1.13.0`. Raw data in `data/probe.jso

* Serves the web app in docs/ and relays POST /v1/systemone to TypeSafe, adding the key from

"""回傳一個已設定好 key 的 TypeSafeClient；拿不到 key 就直接退出、說清楚為什麼。

import { createGateway, experimental_evaluate as evaluate, type Experimental_EvaluationQuestion as EvaluationQuestion } from "ai";

import { TypeSafeClient, choice } from "@typesafe-ai/sdk";

The transport: one POST to `/v1/systemone` per call.