Jev AI Model from TypeSafe AI: A Deep Dive and 10 Best Use Cases

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Customer states: I need to upgrade our enterprise seat count from 50 to 250 ahead of our quarterly audit, but the self-service portal returns an error code 403 on the checkout screen.",
    "questions": {
      "routing_target": {
        "type": "choice",
        "instructions": "Determine the optimal internal queue for this request",
        "criteria": {
          "account_executive": "Contract renegotiation or large tier expansion",
          "billing_support": "Invoice disputes, payment gateway failures, or tax issues",
          "technical_support": "Application errors, 4xx/5xx responses, or bug investigations"
        }
      },
      "customer_churn_risk": {
        "type": "score",
        "instructions": "Evaluate the latent churn risk expressed by the account",
        "criteria": [
          "Low or routine inquiry",
          "Moderate friction but stable account",
          "High risk of contract cancellation"
        ]
      },
      "requires_vp_notification": {
        "type": "noul",
        "instructions": "The customer represents an enterprise account expanding capacity substantially."
      }
    }
  }'

import os
from typesafe_sdk import TypeSafeClient, Choice, Score, Noul

client = TypeSafeClient(
    api_key=os.environ["TYPESAFE_API_KEY"],
    model="jev-1.13.0"
)

state_payload = """
Security Event Log:
IP: 192.168.1.104
Action: Multiple failed SSH attempts (47 attempts within 12 seconds)
User: root
Status: Connection terminated by host firewall
"""

response = client.system_one(
    state=state_payload,
    questions={
        "severity": Choice(
            instructions="Determine incident severity level",
            criteria={
                "p1_critical": "Active breach or lateral enterprise threat",
                "p2_elevated": "Automated brute-force or targeted scanning",
                "p3_informational": "Normal network noise or single login error"
            }
        ),
        "threat_index": Score(
            instructions="Rate the likelihood of malicious human intent",
            criteria=[
                "Negligible probability",
                "Probable script or automated botnet",
                "Targeted advanced persistent actor"
            ]
        ),
        "should_blacklist_subnet": Noul(
            instructions="The IP behavior warrants an immediate CIDR-level firewall drop."
        )
    }
)

severity_choice = response.answers["severity"].choice
severity_conf = response.answers["severity"].confidence
threat_score = response.answers["threat_index"].score
blacklist_prob = response.answers["should_blacklist_subnet"].noul

print(f"Severity: {severity_choice} (Conf: {severity_conf:.2f})")
print(f"Threat Score: {threat_score} | Blacklist Prob: {blacklist_prob:.2f}")

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

interface TriageResult {
  action: "EXECUTE_ROUTING" | "ESCALATE_GENERATIVE_FALLBACK" | "DISPATCH_HUMAN_REVIEW";
  queue?: string;
  metric: number;
}

const client = new TypeSafeClient({
  apiKey: process.env.TYPESAFE_API_KEY!,
  model: "jev-1.13.0",
});

async function evaluateSupportTicket(ticketContent: string): Promise<TriageResult> {
  const result = await client.systemOne({
    state: ticketContent,
    questions: {
      team: {
        type: "choice",
        instructions: "Assign the incoming support communication to an operational unit",
        criteria: {
          billing: "Invoices, credit card charges, refund demands",
          platform: "API latency, rate limits, infrastructure downtime",
          security: "Unauthorized logins, vulnerability reports, credential exposure",
        },
      },
    },
  });

  const triage = result.answers.team;
  const selectedQueue = triage.choice;
  const confidence = triage.confidence;

  if (confidence >= 0.85) {
    return { action: "EXECUTE_ROUTING", queue: selectedQueue, metric: confidence };
  } else if (confidence >= 0.50) {
    return { action: "ESCALATE_GENERATIVE_FALLBACK", queue: selectedQueue, metric: confidence };
  } else {
    return { action: "DISPATCH_HUMAN_REVIEW", metric: confidence };
  }
}

from typesafe_sdk import TypeSafeClient, Noul

client = TypeSafeClient(model="jev-1.13.0")
THRESHOLD = 0.50

inventory_items = [
    "macbook_pro_m3", "usb_c_hub", "desk_lamp", 
    "ergonomic_chair", "thunderbolt_cable", "iphone_15"
]

questions = {
    f"is_computing_hardware_{idx}": Noul(
        instructions=f"Is items[{idx}] a core computing device (computer, phone, tablet) rather than a peripheral or furniture?"
    )
    for idx, _ in enumerate(inventory_items)
}

result = client.system_one(
    state={"items": inventory_items},
    questions=questions
)

computing_device_count = sum(
    result.answers[f"is_computing_hardware_{i}"].noul > THRESHOLD 
    for i in range(len(inventory_items))
)

print(f"Validated computing hardware count: {computing_device_count}")

from typesafe_sdk import TypeSafeClient, Noul, Choice

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

def agent_safety_middleware(proposed_action: dict, session_state: str) -> bool:
    evaluation = client.system_one(
        state=f"Session State: {session_state}\nProposed Tool: {proposed_action['name']}\nParams: {proposed_action['args']}",
        questions={
            "is_destructive": Noul(
                instructions="The proposed action irreversibly modifies, deletes, or drops production resources."
            ),
            "authorization_level": Choice(
                instructions="Determine required user permission level for this tool call",
                criteria={
                    "guest": "Read-only operations",
                    "operator": "Modifications to non-critical staging assets",
                    "admin": "Schema changes, drop commands, credential rotations"
                }
            )
        }
    )
    
    is_destructive_prob = evaluation.answers["is_destructive"].noul
    required_auth = evaluation.answers["authorization_level"].choice
    
    if is_destructive_prob > 0.40 or required_auth == "admin":
        return False
        
    return True