Jev Email Triage

06 / WHY PROBABILITY MATTERS

Uncertainty becomes visible work

A selected queue is useful, but an application also needs a policy for confidence. This demo auto-routes only when the returned selected probability meets the adjustable threshold. A lower value or missing distribution goes to Manual Review.

02 / REAL GMAIL

Want to triage a real Gmail inbox?

Jev Playground deliberately does not request access to your inbox. If you want to run this pattern against real Gmail data, an open-source project called Jevmail implements a local, read-only Gmail workflow.

Demo here or real Gmail?

03 / RUN JEVMAIL LOCALLY

Run the real Gmail version locally

These are Jevmail requirements, not requirements for using the Jev Playground demo: Node.js 22.18+, pnpm, a Google account, a Google Cloud project with a Web OAuth client, and Vercel AI Gateway access.

Source checked at f6f20af. That tracked tree does not contain .env.example, so the verified steps below create .env.local directly.

http://localhost:3000/api/auth/callback/google

git clone https://github.com/fazlerocks/jevmail
cd jevmail
git checkout f6f20af9c2805efd924c29cbea59547e72c558fc
pnpm install

openssl rand -base64 32

if [ -e .env.local ]; then
  printf '%s\n' '.env.local already exists; edit it instead.'
else
  cat > .env.local <<'EOF'
AUTH_SECRET=<paste output from openssl rand -base64 32>
AUTH_GOOGLE_ID=<Google OAuth client ID>
AUTH_GOOGLE_SECRET=<Google OAuth client secret>
AI_GATEWAY_API_KEY=<Vercel AI Gateway API key>
EOF
fi

pnpm dev

Google's External Testing publishing status uses short-lived test refresh-token behavior; Google currently documents a seven-day expiry when broader scopes such as Gmail access are requested. Expect periodic re-authentication and check Google's current OAuth documentation before production use.

04 / PERMISSIONS & DATA FLOW

What can the Gmail connection actually do?

The current Jevmail project requests only https://www.googleapis.com/auth/gmail.readonly. This is an OAuth permission boundary enforced by Google for the granted token.

Read-only Gmail does not mean the email content stays local. Classification requires sending the selected email text to the configured Jev provider. OAuth credentials and tokens, local SQLite data, corrections, and application state stay with the locally running app under the current architecture.

07 / EMAIL TRIAGE ARCHITECTURES

Batch a simulated inbox or classify real mail per message

Neither structure is universally better. They illustrate different batching and application designs. The Jev overview explains the typed primitives behind both.

08 / BUILD THE CLASSIFICATION LAYER

One State, five Choice questions, local policy

This original TypeScript example mirrors the Playground workflow: assemble a bounded queue catalog and five user-edited emails, call typesafe-ai/jev once, validate every answer, then apply an application-owned threshold. It contains no Gmail or external mail API code.

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

const gateway = createGateway({ apiKey: process.env.AI_GATEWAY_API_KEY });
const QUEUES = {
  billing: 'Payments, invoices, refunds, and subscription billing.',
  technical: 'Product faults, errors, broken features, and technical failures.',
  sales: 'Pre-purchase pricing, demos, procurement, and commercial evaluation.',
  account: 'Identity, ownership, access administration, and account recovery.',
  general: 'Legitimate operational mail that fits no other queue.',
  spam_archive: 'Scams, unsolicited promotions, bulk mail, or no-action newsletters.',
};

export async function triageInbox(emails: Array<{
  id: string; from: string; subject: string; body: string;
}>) {
  if (emails.length !== 5) throw new Error('This workflow requires five emails');

  const state = [
    'TASK',
    'Route each email to exactly one operational queue.',
    '',
    'QUEUE DEFINITIONS',
    ...Object.entries(QUEUES).map(([id, definition]) => `${id}: ${definition}`),
    '',
    'INCOMING EMAILS',
    ...emails.flatMap((email) => [
      '', `EMAIL ${email.id}`, `FROM: ${email.from}`,
      `SUBJECT: ${email.subject}`, 'BODY:', email.body,
    ]),
  ].join('\n');

  if (state.length > 8_000) throw new Error('Inbox is too large');

  const questions = Object.fromEntries(emails.map((email, index) => [
    `email_${index + 1}`,
    {
      type: 'choice' as const,
      instructions: `Which work queue should email ${email.id} be routed to?`,
      criteria: QUEUES,
    },
  ]));

  const result = await evaluate({
    model: gateway.evaluationModel('typesafe-ai/jev'),
    state,
    questions,
    maxRetries: 0,
    abortSignal: AbortSignal.timeout(30_000),
    providerOptions: { gateway: { zeroDataRetention: true } },
  });

  const AUTO_ROUTE_THRESHOLD = 0.8; // Application policy.
  return emails.map((email, index) => {
    const answer = result.answers[`email_${index + 1}`];
    if (!answer || answer.type !== 'choice' || !(answer.choice in QUEUES)) {
      throw new Error(`Invalid routing answer for ${email.id}`);
    }
    const probability = answer.probabilities?.[answer.choice];
    return {
      email,
      queue: answer.choice,
      probabilities: answer.probabilities,
      status: probability !== undefined && probability >= AUTO_ROUTE_THRESHOLD
        ? 'AUTO_ROUTE'
        : 'MANUAL_REVIEW',
    };
  });
}

For server-side credentials, public errors, and provider setup, continue to the Jev API guide.

10 / OTHER IMPLEMENTATION PATTERNS

Other ways to build email triage

09 / PRIVACY & PRODUCTION BOUNDARIES

Before connecting a real inbox

Jevmail is an independent side project. It is not affiliated with Jev Playground, TypeSafe AI, Vercel, Google, or their products. Follow its source and Google's current requirements before using real mailbox data.