Putting it in a stack

git clone https://github.com/jaredpalmer/kev.git
cd kev

uv sync --extra serve

# Kev-4B locally; first run downloads the
# adapter and the Qwen3.5 base model.
KEV_DTYPE=bf16 uv run --extra serve \
  python -m kev.serve \
  --run jaredpalmer/kev-4b \
  --port 8009

curl -sS -X POST \
  http://127.0.0.1:8009/v1/systemone \
  -H 'content-type: application/json' \
  -d '{
    "model": "kev-latest",
    "state": "Shoes arrived two weeks late and in
              the wrong size. Also I see two
              charges on my card.",
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
          "returns":  "Exchanges, refunds, wrong items",
          "shipping": "Delivery status, delays",
          "billing":  "Charges, invoices, payments"
        }
      },
      "escalate": {
        "type": "noul",
        "instructions": "Does this need urgent human attention?"
      }
    }
  }'

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

# Point the official SDK at a local server.
# For hosted Jev: drop base_url, use your API key.
client = TypeSafeClient(
    api_key="local",
    base_url="http://127.0.0.1:8009",
    model="kev-latest",
)

response = client.system_one(
    state="I was charged twice. Please fix this ASAP.",
    questions={
        "billing": Noul(
            instructions="Is this ticket about billing?"
        ),
        "tone": Choice(
            instructions="What is the customer's tone?",
            criteria={
                "calm": None,
                "frustrated": None,
                "angry": None,
            },
        ),
        "urgency": Score(
            instructions="How urgent is this ticket?",
            criteria=["can wait", "this week", "today"],
        ),
    },
)

print(response.nouls["billing"].noul)
print(response.choices["tone"].choice)
print(response.scores["urgency"].score)

# Two different questions:
#  - confidence: how clear-cut was the decision?
#  - probabilities[k]: how strong is the winner?

LOW_CONFIDENCE = 0.60   # tune on YOUR data
WEAK_WINNER    = 0.55   # tune on YOUR data

answer = response.choices["department"]

if answer.confidence < LOW_CONFIDENCE:
    # The model itself says this was a close call.
    escalate(ticket, reason="low confidence",
             distribution=answer.probabilities)

elif answer.probabilities[answer.choice] < WEAK_WINNER:
    # It picked something, but nothing dominates.
    escalate(ticket, reason="no dominant option",
             distribution=answer.probabilities)

else:
    dispatch(ticket, queue=answer.choice)

# Log the full distribution, not just the pick.
# This is your training data for the next iteration.

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    ModelChoice,
    ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(
            model="openai:luna",
            criteria="Direct lookups, extraction, and localized changes.",
        ),
        "powerful": ModelChoice(
            model="openai:sol",
            criteria="Architecture and high-stakes decisions.",
        ),
    },
    instructions="Choose the least costly model that can complete the task.",
)

agent = create_agent(
    "openai:gpt-5.6-luna",
    middleware=[router],
)

# The router picks from the latest user message and
# uses that model for the whole run. Probabilities and
# confidence stay available in agent state.

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    AutoModeMiddleware,
)

# Check tool calls for risky decisions before
# the tool executes, and block them if so.
guardrail = AutoModeMiddleware(tools=["bash"])

agent = create_agent(
    "openai:gpt-5.6-luna",
    middleware=[guardrail],
)

from typesafe_sdk import Noul, TypeSafeClient

client = TypeSafeClient(model="jev-1.13")

# Jev does not count reliably. So don't ask it to.
# Ask one yes/no question PER ITEM, then add up the
# answers in ordinary code.
YES = 0.5   # pick a threshold that suits your use case

items = ["typesafe", "apple", "california", "banana",
         "likes", "calibration", "orange", "vertex"]

result = client.system_one(
    {"items": items},
    {
        f"item_{i}": Noul(
            instructions=f"Is `items[{i}]` the name of a fruit?"
        )
        for i in range(len(items))
    },
)

count = sum(
    result.nouls[f"item_{i}"].noul > YES
    for i in range(len(items))
)

# Don't ask for a value and hope it comes back clean.
# Enumerate the possibilities and let it pick.

questions = {
    "month": {
        "type": "choice",
        "instructions": "Which month does this deadline fall in?",
        "criteria": {
            "january": None, "february": None,
            "march": None, "april": None,
            # ... twelve months, bounded set
            "not stated": "The deadline does not name a month",
        },
    },
    "day": {
        "type": "choice",
        "instructions": "Which day of the month?",
        "criteria": {str(d): None for d in range(1, 32)},
    },
}

# Every part of a date is a small closed set, which
# turns extraction into a Choice rather than free-form
# parsing -- and gives you somewhere to put an explicit
# "not stated" so a missing part is reported, not guessed.
# Code then assembles the parts and owns ordering,
# duration, offsets and weekday arithmetic.