Jev API

curl https://api.typesafe.ai/v1/systemone \
  --request POST \
  --header "Authorization: Bearer $TYPESAFE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "jev-latest",
    "state": "The customer says their production service is down.",
    "questions": {
      "urgent": {
        "type": "noul",
        "instructions": "Is this request urgent?"
      }
    }
  }'

npm install @typesafe-ai/sdk

TYPESAFE_API_KEY=

import { noul, TypeSafeClient } from '@typesafe-ai/sdk';

const client = new TypeSafeClient(); // reads TYPESAFE_API_KEY
const response = await client.systemOne({
  state: 'The customer says their production service is down.',
  questions: {
    urgent: noul('Is this request urgent?'),
  },
});

console.log(response.answers.urgent.noul);

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

const client = new TypeSafeClient(); // reads TYPESAFE_API_KEY
const response = await client.systemOne({
  state: {
    message: 'I was charged twice and cannot access my account.',
    accountStatus: 'locked',
  },
  questions: {
    refundReview: noul('Does this request require refund review?', {
      true: 'A duplicate or incorrect charge needs review',
      false: 'No billing correction is requested',
    }),
    team: choice('Which team should handle this first?', {
      billing: 'Payment or refund problems',
      technical: 'Account access or product problems',
    }),
    urgency: score('How urgently does this need attention?', [
      'Routine',
      'Time-sensitive',
      'Blocked',
    ]),
  },
});

console.log(response.answers.refundReview.noul);
console.log(response.answers.team.choice);
console.log(response.answers.urgency.score);

pip install typesafe-sdk

export TYPESAFE_API_KEY="your-key"

from typesafe_sdk import Noul, TypeSafeClient

with TypeSafeClient() as client:  # reads TYPESAFE_API_KEY
    response = client.system_one(
        state="The customer says their production service is down.",
        questions={
            "urgent": Noul(instructions="Is this request urgent?")
        },
    )

print(response.nouls["urgent"].noul)

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

questions = {
    "refund_review": Noul(
        instructions="Does this request require refund review?",
        criteria={
            "true": "A duplicate or incorrect charge needs review",
            "false": "No billing correction is requested",
        },
    ),
    "team": Choice(
        instructions="Which team should handle this first?",
        criteria={
            "billing": "Payment or refund problems",
            "technical": "Account access or product problems",
        },
    ),
    "urgency": Score(
        instructions="How urgently does this need attention?",
        criteria=["Routine", "Time-sensitive", "Blocked"],
    ),
}

with TypeSafeClient() as client:  # reads TYPESAFE_API_KEY
    response = client.system_one(
        state={
            "message": "I was charged twice and cannot access my account.",
            "account_status": "locked",
        },
        questions=questions,
    )

print(response.nouls["refund_review"].noul)
print(response.choices["team"].choice)
print(response.scores["urgency"].score)

import { createGateway, experimental_evaluate as evaluate } from 'ai';

const gateway = createGateway({
  apiKey: process.env.AI_GATEWAY_API_KEY,
});

const result = await evaluate({
  model: gateway.evaluationModel('typesafe-ai/jev'),
  state: {
    message: 'I was charged twice and cannot access my account.',
    accountStatus: 'locked',
  },
  questions: {
    team: {
      type: 'choice',
      instructions: 'Which team should handle this first?',
      criteria: {
        billing: 'Payment or refund problems',
        technical: 'Account access or product problems',
      },
    },
    urgency: {
      type: 'score',
      instructions: 'How urgently does this need attention?',
      criteria: ['Routine', 'Time-sensitive', 'Blocked'],
    },
    refundReview: {
      type: 'boolean',
      instructions: 'Does the customer request require refund review?',
    },
  },
  maxRetries: 0,
  abortSignal: AbortSignal.timeout(30_000),
  providerOptions: { gateway: { zeroDataRetention: true } },
});

console.log(result.answers.team.choice);
console.log(result.answers.urgency.score);
console.log(result.answers.refundReview.probability);

{
  "model": "jev-1.13.0",
  "answers": {
    "refund_review": { "type": "noul", "noul": 0.98 },
    "team": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.94, "technical": 0.06 },
      "confidence": 0.91
    },
    "urgency": {
      "type": "score",
      "score": 1.8,
      "legend": { "0": "Routine", "1": "Time-sensitive", "2": "Blocked" },
      "probabilities": { "0": 0.02, "1": 0.16, "2": 0.82 },
      "confidence": 0.88
    }
  },
  "usage": { "input_tokens": 214, "output_tokens": 18 }
}

{
  "type": "boolean",
  "probability": 0.99
}

{
  "type": "choice",
  "choice": "Billing",
  "probabilities": {
    "Billing": 1,
    "Technical": 0,
    "Sales": 0,
    "Other": 0
  }
}

{
  "type": "score",
  "score": 4,
  "probabilities": { "0": 0, "1": 0, "2": 0, "3": 0, "4": 1 }
}

// Example policy for the Gateway Choice result above.
const decision = result.answers.team;
const p = decision.probabilities?.[decision.choice];
const action =
  p == null ? 'human-review' :
  p >= 0.90 ? 'automate' :
  p >= 0.60 ? 'verify' :
  'human-review';

// Your application decides which action is permitted.
console.log(action);

// Gateway errors: keep retries and messages under application control.
async function verifyRefund(state: string) {
  const timeout = AbortSignal.timeout(30_000);
  try {
    const result = await evaluate({
      model: gateway.evaluationModel('typesafe-ai/jev'),
      state,
      questions: {
        refunded: { type: 'boolean', instructions: 'Was a refund issued?' },
      },
      maxRetries: 0,
      abortSignal: timeout,
      providerOptions: { gateway: { zeroDataRetention: true } },
    });
    return { ok: true, answer: result.answers.refunded };
  } catch {
    return {
      ok: false,
      error: timeout.aborted
        ? 'Evaluation timed out.'
        : 'Evaluation unavailable. Please try later.',
    };
  }
}

providerOptions: {
  gateway: { zeroDataRetention: true },
}

npm install ai@7.0.105

import { createGateway, experimental_evaluate as evaluate } from 'ai';

const gateway = createGateway({
  apiKey: process.env.AI_GATEWAY_API_KEY,
});

const result = await evaluate({
  model: gateway.evaluationModel('typesafe-ai/jev'),
  state: 'The support agent issued a full refund.',
  questions: {
    refunded: {
      type: 'boolean',
      instructions: 'Was a refund issued?',
    },
  },
  maxRetries: 0,
  abortSignal: AbortSignal.timeout(30_000),
  providerOptions: { gateway: { zeroDataRetention: true } },
});

console.log(result.answers.refunded.probability);

import { createGateway, experimental_evaluate as evaluate } from 'ai';

const gateway = createGateway({
  apiKey: process.env.AI_GATEWAY_API_KEY,
});

const result = await evaluate({
  model: gateway.evaluationModel('typesafe-ai/jev'),
  state: 'I was charged twice. Please refund the extra charge.',
  questions: {
    team: {
      type: 'choice',
      instructions: 'Which team should handle this customer request?',
      criteria: {
        billing: 'Charges, payments, and refunds',
        technical: 'Bugs and technical problems',
        sales: 'Questions before purchasing',
        other: 'Requests outside the categories above',
      },
    },
  },
  maxRetries: 0,
  abortSignal: AbortSignal.timeout(30_000),
  providerOptions: { gateway: { zeroDataRetention: true } },
});

const answer = result.answers.team;
console.log(answer.choice);
console.log(answer.probabilities?.[answer.choice]);

import { createGateway, experimental_evaluate as evaluate } from 'ai';

const gateway = createGateway({
  apiKey: process.env.AI_GATEWAY_API_KEY,
});

const result = await evaluate({
  model: gateway.evaluationModel('typesafe-ai/jev'),
  state: 'Production is completely unavailable to all customers.',
  questions: {
    urgency: {
      type: 'score',
      instructions: 'How urgent is this incident?',
      criteria: ['No urgency', 'Low', 'Moderate', 'High', 'Critical'],
    },
  },
  maxRetries: 0,
  abortSignal: AbortSignal.timeout(30_000),
  providerOptions: { gateway: { zeroDataRetention: true } },
});

console.log(result.answers.urgency.score);
console.log(result.answers.urgency.probabilities);

export default {
  async fetch(_request, env) {
    const result = await env.AI.run('typesafe/jev', {
      state: 'A customer reports a duplicate card charge.',
      questions: {
        refund_review: {
          type: 'noul',
          instructions: 'Does this request require refund review?',
        },
      },
    });

    return Response.json(result);
  },
};