Building Interfaces That Understand What We Want to Do

const $check = document.querySelector( '#check' );

const schema = {
	context: 'An online store gets messages from its customers.',
	// The model gets text in English. It also takes es, ja, de and fr.
	expectedInputs: [ { type: 'text', languages: [ 'en' ] } ],
	questions: [
		{
			id: 'upset',
			type: 'boolean',
			prompt: 'Is this customer upset?',
		},
	],
	// Temporary option for Gemma 4 instead of EmbeddingGemma.
	devTrialBackend: 'language-model',
};

let model;

// Browsers without the API skip this, and the page keeps working.
// Chrome reports 'unavailable', 'downloadable', 'downloading' or 'available'.
if (
	'DecisionModel' in window
	&& await DecisionModel.availability( schema ) !== 'unavailable'
) {
	$check.addEventListener( 'click', async () => {
		// Chrome downloads the model on the first create().
		model ??= await DecisionModel.create( schema );

		const { upset } = await model.decide( 'You charged my card twice!' );

		// The label is 'true' or 'false', with a probability for each one.
		console.log( upset.label, upset.probabilities );
	} );
}

import { DecisionMaker, FilesetResolver } from '@mediapipe/tasks-decision';

const wasm = await FilesetResolver.forDecisionTasks(
	'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-decision@1.2.0/wasm',
);

// EmbeddingGemma 2 270M, about 165 MB, downloaded by each site that uses it.
const modelUrl = 'https://huggingface.co/litert-community'
	+ '/embeddinggemma-2-text-270m-litert-lm'
	+ '/resolve/main/embeddinggemma-2-text-270m.litertlm';

const maker = await DecisionMaker.createFromOptions( wasm, {
	baseOptions: { modelAssetPath: modelUrl },
	// The token budget Google's EmbeddingGemma 2 sample uses.
	maxNumTokens: 256,
} );

const context = 'An online store gets messages from its customers.';
const message = 'You charged my card twice!';

// The condition is a statement, not a question.
const answer = await maker.evaluateBoolean( message, {
	context,
	condition: 'This customer is upset.',
} );

// The value is true or false, with the probability that it's true.
console.log( answer.value, answer.probabilityTrue );

// server.js
// Works with @google/genai 2.29.1 or later.
import { GoogleGenAI } from '@google/genai';

const gemini = new GoogleGenAI( {
	apiKey: process.env.GEMINI_API_KEY,
	// Versions of the SDK before 3.0 call v1beta, the beta version of the API, unless you pick v1.
	httpOptions: { apiVersion: 'v1' },
} );

const context = 'An online store gets messages from its customers.';
const message = 'You charged my card twice!';

const interaction = await gemini.interactions.create( {
	model: 'gemini-3.5-flash-lite',
	system_instruction: `${context} Is this customer upset?`,
	input: message,
	response_format: {
		type: 'text',
		mime_type: 'application/json',
		schema: {
			type: 'object',
			properties: { upset: { type: 'boolean' } },
			required: [ 'upset' ],
		},
	},
	generation_config: { thinking_level: 'minimal' },
	// Google stores interactions unless you send store: false.
	store: false,
} );
const reply = interaction.status === 'completed' && interaction.output_text
	? JSON.parse( interaction.output_text )
	: null;

// The pick, true or false. Gemini doesn't return a probability.
console.log( reply?.upset );

// server.js
// decisions with JSON input needs the openai package 7.43.0 or later.
import OpenAI from 'openai';

const openai = new OpenAI( { apiKey: process.env.OPENAI_API_KEY } );

const context = 'An online store gets messages from its customers.';
const message = 'You charged my card twice!';
const state = { message };

const decision = await openai.decisions.create( {
	model: 'gpt-6-luna',
	input: [ { role: 'user', content: [ { type: 'input_json', data: state } ] } ],
	questions: [
		{
			type: 'predicate',
			name: 'upset',
			instructions: `${context} Is this customer upset?`,
		},
	],
} );
const answer = decision.answers.find( ( a ) => a.name === 'upset' );

// The probability that the answer is yes, or null if the model refused.
console.log( answer?.type === 'predicate' ? answer.probability : null );

// server.js
// Works with @anthropic-ai/sdk 1.6.0 or later.
import Anthropic from '@anthropic-ai/sdk';

const claude = new Anthropic( { apiKey: process.env.ANTHROPIC_API_KEY } );

const context = 'An online store gets messages from its customers.';
const message = 'You charged my card twice!';

const response = await claude.messages.create( {
	model: 'claude-haiku-5-5',
	max_tokens: 1024,
	// No thinking and low effort, so it answers fast.
	thinking: { type: 'disabled' },
	system: `${context} Is this customer upset?`,
	messages: [ { role: 'user', content: message } ],
	output_config: {
		effort: 'low',
		format: {
			type: 'json_schema',
			schema: {
				type: 'object',
				properties: { upset: { type: 'boolean' } },
				required: [ 'upset' ],
				additionalProperties: false,
			},
		},
	},
} );
const text = response.stop_reason === 'end_turn'
	? response.content.find( ( block ) => block.type === 'text' )?.text
	: null;

// The pick, true or false, or null if Claude refused. Claude doesn't return a probability.
console.log( text ? JSON.parse( text ).upset : null );

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

const jev = new TypeSafeClient( { apiKey: process.env.TYPESAFE_API_KEY } );

const context = 'An online store gets messages from its customers.';
const message = 'You charged my card twice!';

const { answers } = await jev.systemOne( {
	model: 'jev-1.14.0',
	state: { message },
	questions: {
		upset: noul( `${context} Is this customer upset?` ),
	},
} );

// The probability that the answer is yes.
console.log( answers.upset.noul );

// Set from the cost of a wrong guess, then checked on Gemma 4 on CPU with my test phrases.
const MIN_PROBABILITY = 0.35;
// The gate can open if the model picks the answer option by mistake.
// If the model misses that option, the guard only asks again.
// On the third miss in one turn, he politely turns the visitor away.
// Gemma 4 got the most of my test phrases right, with no wrong yes, anywhere from 0.50 to 0.56.
// 0.53 is halfway.
const MIN_ANSWERED = 0.53;

// Runs every time the visitor answers the guard's first question.
// castleModel is the session from the setup above.
async function guardMove( said ) {
	const input = `Visitor says: "${said}"`;
	const { reaction, answered } = await castleModel.decide( input );

	// applyRules() runs the game's rules on these values and returns the guard's move.
	return applyRules( {
		chosen: reaction.label,
		sure: reaction.probabilities[ reaction.label ] >= MIN_PROBABILITY,
		answered: answered.label === 'gave_purpose' && answered.probabilities[ answered.label ] >= MIN_ANSWERED,
		hostile: answered.label === 'hostile',
	} );
}

// Not measured on EmbeddingGemma 2. Tune both with your own phrases.
const MIN_PROBABILITY = 0.5;
const MIN_ANSWERED = 0.5;

const context = 'A castle guard decides how to react to a visitor at the gate who wants to see the king.';

// Runs every time the visitor answers the guard's first question.
// maker is the MediaPipe Decision Maker, already loaded.
async function guardMove( said ) {
	const input = `Visitor says: "${said}"`;
	const reaction = await maker.evaluateChoice( input, {
		context,
		instructions: 'How should the guard react to what the visitor said?',
		options: [
			{
				label: 'request_proof',
				description: 'Unproven claim, ask who sent them, demand proof or papers',
			},
			{
				label: 'deny_politely',
				description: 'Calm, polite refusal, kindly turn them away',
			},
			{
				label: 'allow_stern',
				description: 'Acceptable but not fully trusted, let them in reluctantly and stay wary',
			},
			{
				label: 'allow_friendly',
				description: 'Trusted or clearly expected, gladly admit them with warmth',
			},
			{
				label: 'deny_aggressively',
				description: 'Bribe attempt, angry refusal, shout at them and send them away',
			},
			{
				label: 'call_backup',
				description: 'Hostile threats, raise the alarm and summon reinforcements',
			},
			{
				label: 'attack',
				description: 'Threat to kill, hurt or harm, weapons, violence, fight',
			},
		],
	} );
	const answered = await maker.evaluateChoice( input, {
		context,
		instructions: 'Judge only the visitor\'s words. '
			+ 'The guard asked why they came. '
			+ 'What did the visitor do in answer?',
		options: [
			{
				label: 'gave_purpose',
				description: 'Said why they came or what they want, true or not',
			},
			{
				label: 'small_talk',
				description: 'Only a greeting, a name, small talk or a question back, no reason given',
			},
			{
				label: 'hostile',
				description: 'Threatened, insulted or offered a bribe',
			},
			{
				label: 'unclear',
				description: 'Unclear, unrelated or nonsense',
			},
		],
	} );

	// applyRules() runs the game's rules on these values and returns the guard's move.
	return applyRules( {
		chosen: reaction.selectedKey,
		sure: reaction.probabilities[ reaction.selectedKey ] >= MIN_PROBABILITY,
		answered: answered.selectedKey === 'gave_purpose' && answered.probabilities[ answered.selectedKey ] >= MIN_ANSWERED,
		hostile: answered.selectedKey === 'hostile',
	} );
}

// server.js
const context = 'A castle guard decides how to react to a visitor at the gate who wants to see the king.';

const labels = [
	'request_proof',
	'deny_politely',
	'allow_stern',
	'allow_friendly',
	'deny_aggressively',
	'call_backup',
	'attack',
];
const answers = [ 'gave_purpose', 'small_talk', 'hostile', 'unclear' ];
const { said } = req.body;
const input = `Visitor says: "${said}"`;

// gemini is the GoogleGenAI client, set up with your API key.
const interaction = await gemini.interactions.create( {
	model: 'gemini-3.5-flash-lite',
	system_instruction: [
		context,
		'How should the guard react to what the visitor said? Pick one reaction:',
		'request_proof: Unproven claim, ask who sent them, demand proof or papers',
		'deny_politely: Calm, polite refusal, kindly turn them away',
		'allow_stern: Acceptable but not fully trusted, let them in reluctantly and stay wary',
		'allow_friendly: Trusted or clearly expected, gladly admit them with warmth',
		'deny_aggressively: Bribe attempt, angry refusal, shout at them and send them away',
		'call_backup: Hostile threats, raise the alarm and summon reinforcements',
		'attack: Threat to kill, hurt or harm, weapons, violence, fight',
		'Also answer: Judge only the visitor\'s words. '
			+ 'The guard asked why they came. '
			+ 'What did the visitor do in answer? Pick one:',
		'gave_purpose: Said why they came or what they want, true or not',
		'small_talk: Only a greeting, a name, small talk or a question back, no reason given',
		'hostile: Threatened, insulted or offered a bribe',
		'unclear: Unclear, unrelated or nonsense',
	].join( '\n' ),
	input,
	response_format: {
		type: 'text',
		mime_type: 'application/json',
		schema: {
			type: 'object',
			properties: {
				reaction: { type: 'string', enum: labels },
				answered: { type: 'string', enum: answers },
			},
			required: [ 'reaction', 'answered' ],
		},
	},
	generation_config: { thinking_level: 'minimal' },
	// Google stores interactions unless you send store: false.
	store: false,
} );
const reply = interaction.status === 'completed' && interaction.output_text
	? JSON.parse( interaction.output_text )
	: null;

// Without probabilities from Gemini, the reaction always counts as sure.
// The if checks that the reaction is one of your labels.
if ( labels.includes( reply?.reaction ) ) {
	// The browser runs the game's rules on these four values.
	res.json( {
		chosen: reply.reaction,
		sure: true,
		answered: reply.answered === 'gave_purpose',
		hostile: reply.answered === 'hostile',
	} );
} else {
	// An error status shows the no-model state in the browser.
	res.sendStatus( 502 );
}

// server.js
const context = 'A castle guard decides how to react to a visitor at the gate who wants to see the king.';

// Not measured on gpt-6-luna. Tune both with your own phrases.
const MIN_PROBABILITY = 0.5;
const MIN_ANSWERED = 0.5;

const { said } = req.body;
const state = { visitorSaid: said };

// openai is the OpenAI client, set up with your API key.
const decision = await openai.decisions.create( {
	model: 'gpt-6-luna',
	input: [ { role: 'user', content: [ { type: 'input_json', data: state } ] } ],
	questions: [
		{
			type: 'choice',
			name: 'reaction',
			instructions: `${context} How should the guard react to what the visitor said?`,
			choices: [
				{
					value: 'request_proof',
					description: 'Unproven claim, ask who sent them, demand proof or papers',
				},
				{
					value: 'deny_politely',
					description: 'Calm, polite refusal, kindly turn them away',
				},
				{
					value: 'allow_stern',
					description: 'Acceptable but not fully trusted, let them in reluctantly and stay wary',
				},
				{
					value: 'allow_friendly',
					description: 'Trusted or clearly expected, gladly admit them with warmth',
				},
				{
					value: 'deny_aggressively',
					description: 'Bribe attempt, angry refusal, shout at them and send them away',
				},
				{
					value: 'call_backup',
					description: 'Hostile threats, raise the alarm and summon reinforcements',
				},
				{
					value: 'attack',
					description: 'Threat to kill, hurt or harm, weapons, violence, fight',
				},
			],
		},
		{
			type: 'choice',
			name: 'answered',
			instructions: `${context} Judge only the visitor's words. `
				+ 'The guard asked why they came. '
				+ 'What did the visitor do in answer?',
			choices: [
				{
					value: 'gave_purpose',
					description: 'Said why they came or what they want, true or not',
				},
				{
					value: 'small_talk',
					description: 'Only a greeting, a name, small talk or a question back, no reason given',
				},
				{
					value: 'hostile',
					description: 'Threatened, insulted or offered a bribe',
				},
				{
					value: 'unclear',
					description: 'Unclear, unrelated or nonsense',
				},
			],
		},
	],
} );
const reaction = decision.answers.find( ( a ) => a.name === 'reaction' );
const answered = decision.answers.find( ( a ) => a.name === 'answered' );
const chosen = reaction?.type === 'choice'
	? reaction.probabilities.find( ( p ) => p.value === reaction.choice )
	: undefined;
const picked = answered?.type === 'choice'
	? answered.probabilities.find( ( p ) => p.value === answered.choice )
	: undefined;

// A refusal counts as not sure or no answer before the rules run.
// The browser runs the game's rules on these four values.
res.json( {
	chosen: chosen?.value ?? null,
	sure: chosen !== undefined && chosen.probability >= MIN_PROBABILITY,
	answered: picked !== undefined && picked.value === 'gave_purpose' && picked.probability >= MIN_ANSWERED,
	hostile: picked?.value === 'hostile',
} );

// server.js
const context = 'A castle guard decides how to react to a visitor at the gate who wants to see the king.';

const labels = [
	'request_proof',
	'deny_politely',
	'allow_stern',
	'allow_friendly',
	'deny_aggressively',
	'call_backup',
	'attack',
];
const answers = [ 'gave_purpose', 'small_talk', 'hostile', 'unclear' ];
const { said } = req.body;
const input = `Visitor says: "${said}"`;

// claude is the Anthropic client, set up with your API key.
const response = await claude.messages.create( {
	model: 'claude-haiku-5-5',
	max_tokens: 1024,
	thinking: { type: 'disabled' },
	system: [
		context,
		'How should the guard react to what the visitor said? Pick one reaction:',
		'request_proof: Unproven claim, ask who sent them, demand proof or papers',
		'deny_politely: Calm, polite refusal, kindly turn them away',
		'allow_stern: Acceptable but not fully trusted, let them in reluctantly and stay wary',
		'allow_friendly: Trusted or clearly expected, gladly admit them with warmth',
		'deny_aggressively: Bribe attempt, angry refusal, shout at them and send them away',
		'call_backup: Hostile threats, raise the alarm and summon reinforcements',
		'attack: Threat to kill, hurt or harm, weapons, violence, fight',
		'Also answer: Judge only the visitor\'s words. '
			+ 'The guard asked why they came. '
			+ 'What did the visitor do in answer? Pick one:',
		'gave_purpose: Said why they came or what they want, true or not',
		'small_talk: Only a greeting, a name, small talk or a question back, no reason given',
		'hostile: Threatened, insulted or offered a bribe',
		'unclear: Unclear, unrelated or nonsense',
	].join( '\n' ),
	messages: [ { role: 'user', content: input } ],
	output_config: {
		effort: 'low',
		format: {
			type: 'json_schema',
			schema: {
				type: 'object',
				properties: {
					reaction: { type: 'string', enum: labels },
					answered: { type: 'string', enum: answers },
				},
				required: [ 'reaction', 'answered' ],
				additionalProperties: false,
			},
		},
	},
} );
const text = response.stop_reason === 'end_turn'
	? response.content.find( ( block ) => block.type === 'text' )?.text
	: null;
const reply = text ? JSON.parse( text ) : null;

// Without probabilities from Claude, the reaction always counts as sure.
// The if checks that the reaction is one of your labels.
if ( labels.includes( reply?.reaction ) ) {
	// The browser runs the game's rules on these four values.
	res.json( {
		chosen: reply.reaction,
		sure: true,
		answered: reply.answered === 'gave_purpose',
		hostile: reply.answered === 'hostile',
	} );
} else {
	// An error status shows the no-model state in the browser.
	res.sendStatus( 502 );
}

// server.js
import { choice } from '@typesafe-ai/sdk';

const context = 'A castle guard decides how to react to a visitor at the gate who wants to see the king.';

// Set from the cost of a wrong guess, then checked on jev-1.14.0 with my test phrases.
const MIN_PROBABILITY = 0.35;
// The gate can open if the model picks the answer option by mistake.
// If the model misses that option, the guard only asks again.
// On the third miss in one turn, he politely turns the visitor away.
// Above one half, Jev got the most of my test phrases right, with no wrong yes, at 0.51 and 0.52.
// 0.52 is a bit above the middle, on the careful side.
const MIN_ANSWERED = 0.52;

const { said } = req.body;

// jev is the TypeSafeClient, set up with your API key.
const { answers } = await jev.systemOne( {
	model: 'jev-1.14.0',
	state: { visitorSaid: said },
	questions: {
		reaction: choice(
			`${context} How should the guard react to what the visitor said?`,
			{
				request_proof: 'Unproven claim, ask who sent them, demand proof or papers',
				deny_politely: 'Calm, polite refusal, kindly turn them away',
				allow_stern: 'Acceptable but not fully trusted, let them in reluctantly and stay wary',
				allow_friendly: 'Trusted or clearly expected, gladly admit them with warmth',
				deny_aggressively: 'Bribe attempt, angry refusal, shout at them and send them away',
				call_backup: 'Hostile threats, raise the alarm and summon reinforcements',
				attack: 'Threat to kill, hurt or harm, weapons, violence, fight',
			},
		),
		answered: choice(
			`${context} Judge only the visitor's words. `
				+ 'The guard asked why they came. '
				+ 'What did the visitor do in answer?',
			{
				gave_purpose: 'Said why they came or what they want, true or not',
				small_talk: 'Only a greeting, a name, small talk or a question back, no reason given',
				hostile: 'Threatened, insulted or offered a bribe',
				unclear: 'Unclear, unrelated or nonsense',
			},
		),
	},
} );
const { reaction, answered } = answers;

// The browser runs the game's rules on these four values.
res.json( {
	chosen: reaction.choice,
	sure: reaction.probabilities[ reaction.choice ] >= MIN_PROBABILITY,
	answered: answered.choice === 'gave_purpose' && answered.probabilities[ answered.choice ] >= MIN_ANSWERED,
	hostile: answered.choice === 'hostile',
} );

const composerModel = await DecisionModel.create( {
	context: 'A software company\'s chat app checks a draft before it is sent to a channel or a person.',
	expectedInputs: [ { type: 'text', languages: [ 'en' ] } ],
	questions: [
		{
			id: 'sensitive',
			type: 'boolean',
			prompt: 'Is this message too sensitive or inappropriate for its channel and audience?',
		},
	],
	// Temporary option for Gemma 4 instead of EmbeddingGemma.
	devTrialBackend: 'language-model',
} );

// Just above my closest harmless test draft (0.9765) on Gemma 4 on CPU,
// since a missed warning costs more than one extra click.
const RISK_THRESHOLD = 0.98;

// When a direct message names the person who gets it.
const NAMED_RECIPIENT_THRESHOLD = 0.7;

// Checks a draft, and returns whether to show the warning.
// channel is "public" or something like "direct message to Clara",
// recipient is the person who gets a direct message,
// and audience is how many people will see the message.
async function shouldWarn( { draft, channel, audience, recipient } ) {
	const input = `Message: "${draft}" Channel: ${channel}. Audience: ${audience} ${audience === 1 ? 'person' : 'people'}.`;
	const { sensitive } = await composerModel.decide( input );

	// Whether the message has the recipient's name as a whole word, in any case.
	const words = draft.toLowerCase().split( /[^\p{L}\p{N}]+/u );
	const namesRecipient = channel !== 'public' && words.includes( recipient.toLowerCase() );
	const threshold = namesRecipient ? NAMED_RECIPIENT_THRESHOLD : RISK_THRESHOLD;

	return sensitive.probabilities.true >= threshold;
}

// The default threshold of evaluateBoolean, not measured on my drafts.
const RISK_THRESHOLD = 0.5;

const context = 'A software company\'s chat app checks a draft before it is sent to a channel or a person.';

// Checks a draft, and returns whether to show the warning.
// channel is "public" or something like "direct message to Clara",
// and audience is how many people will see the message.
// maker is the MediaPipe Decision Maker, already loaded.
async function shouldWarn( { draft, channel, audience } ) {
	const input = `Message: "${draft}" Channel: ${channel}. Audience: ${audience} ${audience === 1 ? 'person' : 'people'}.`;
	const answer = await maker.evaluateBoolean( input, {
		context,
		condition: 'This message is too sensitive or inappropriate for its channel and audience.',
	} );

	return answer.probabilityTrue >= RISK_THRESHOLD;
}

// server.js
const context = 'A software company\'s chat app checks a draft before it is sent to a channel or a person.';

// channel is "public" or something like "direct message to Clara",
// and audience is how many people will see the message.
const { draft, channel, audience } = req.body;
const input = `Message: "${draft}" Channel: ${channel}. Audience: ${audience} ${audience === 1 ? 'person' : 'people'}.`;

// gemini is the GoogleGenAI client, set up with your API key.
const interaction = await gemini.interactions.create( {
	model: 'gemini-3.5-flash-lite',
	system_instruction: `${context} Is this message too sensitive or inappropriate for its channel and audience?`,
	input,
	response_format: {
		type: 'text',
		mime_type: 'application/json',
		schema: {
			type: 'object',
			properties: { sensitive: { type: 'boolean' } },
			required: [ 'sensitive' ],
		},
	},
	generation_config: { thinking_level: 'minimal' },
	store: false,
} );
const reply = interaction.status === 'completed' && interaction.output_text
	? JSON.parse( interaction.output_text )
	: null;

if ( reply?.sensitive === true ) {
	res.json( { warn: true } );
} else {
	res.json( { warn: false } );
}

// server.js
// Not measured on gpt-6-luna. Tune it with your own drafts.
const RISK_THRESHOLD = 0.5;

const context = 'A software company\'s chat app checks a draft before it is sent to a channel or a person.';

// channel is "public" or something like "direct message to Clara",
// and audience is how many people will see the message.
const { draft, channel, audience } = req.body;
const state = { message: draft, channel, audience };

// openai is the OpenAI client, set up with your API key.
const decision = await openai.decisions.create( {
	model: 'gpt-6-luna',
	input: [ { role: 'user', content: [ { type: 'input_json', data: state } ] } ],
	questions: [
		{
			type: 'predicate',
			name: 'sensitive',
			instructions: `${context} Is this message too sensitive or inappropriate for its channel and audience?`,
		},
	],
} );
const answer = decision.answers.find( ( a ) => a.name === 'sensitive' );

if ( answer?.type === 'predicate' && answer.probability >= RISK_THRESHOLD ) {
	res.json( { warn: true } );
} else {
	res.json( { warn: false } );
}

// server.js
const context = 'A software company\'s chat app checks a draft before it is sent to a channel or a person.';

// channel is "public" or something like "direct message to Clara",
// and audience is how many people will see the message.
const { draft, channel, audience } = req.body;
const input = `Message: "${draft}" Channel: ${channel}. Audience: ${audience} ${audience === 1 ? 'person' : 'people'}.`;

// claude is the Anthropic client, set up with your API key.
const response = await claude.messages.create( {
	model: 'claude-haiku-5-5',
	max_tokens: 1024,
	thinking: { type: 'disabled' },
	system: `${context} Is this message too sensitive or inappropriate for its channel and audience?`,
	messages: [ { role: 'user', content: input } ],
	output_config: {
		effort: 'low',
		format: {
			type: 'json_schema',
			schema: {
				type: 'object',
				properties: { sensitive: { type: 'boolean' } },
				required: [ 'sensitive' ],
				additionalProperties: false,
			},
		},
	},
} );
const text = response.stop_reason === 'end_turn'
	? response.content.find( ( block ) => block.type === 'text' )?.text
	: null;
const reply = text ? JSON.parse( text ) : null;

if ( reply?.sensitive === true ) {
	res.json( { warn: true } );
} else {
	res.json( { warn: false } );
}

// server.js
import { noul } from '@typesafe-ai/sdk';

// Set from the cost of a wrong guess, then checked on jev-1.14.0 with my test drafts.
const RISK_THRESHOLD = 0.7;

const context = 'A software company\'s chat app checks a draft before it is sent to a channel or a person.';

// channel is "public" or something like "direct message to Clara",
// and audience is how many people will see the message.
const { draft, channel, audience } = req.body;

// jev is the TypeSafeClient, set up with your API key.
const { answers } = await jev.systemOne( {
	model: 'jev-1.14.0',
	state: { message: draft, channel, audience },
	questions: {
		sensitive: noul( `${context} Is this message too sensitive or inappropriate for its channel and audience?` ),
	},
} );

if ( answers.sensitive.noul >= RISK_THRESHOLD ) {
	res.json( { warn: true } );
} else {
	res.json( { warn: false } );
}

const selectionModel = await DecisionModel.create( {
	context: 'A reader selected some text and the app suggests one action for it.',
	expectedInputs: [ { type: 'text', languages: [ 'en' ] } ],
	questions: [
		{
			id: 'action',
			type: 'choice',
			prompt: 'Which action fits the selected text?',
			options: [
				{
					label: 'create_task',
					description: 'Work someone must do, a problem to solve, a to-do or assignment',
				},
				{
					label: 'save_in_calendar',
					description: 'A meeting, event or appointment with a date and time',
				},
				{
					label: 'set_reminder',
					description: 'A follow-up later, remember to check back or reply',
				},
				{
					label: 'none',
					description: 'No action fits, just thanks, chatter, news or several different actions',
				},
			],
		},
	],
	// Temporary option for Gemma 4 instead of EmbeddingGemma.
	devTrialBackend: 'language-model',
} );

// Set from the cost of a wrong guess, then checked on Gemma 4 on CPU with my test selections.
const MIN_PROBABILITY = 0.5;

// Runs when the reader selects text, and returns the action to show next to Quote, or null.
async function suggestAction( selected ) {
	const { action } = await selectionModel.decide( `Selected text: "${selected}"` );

	if ( action.label !== 'none' && action.probabilities[ action.label ] >= MIN_PROBABILITY ) {
		return action.label;
	}
	return null;
}

// Not measured on EmbeddingGemma 2. Tune it with your own selections.
const MIN_PROBABILITY = 0.5;

const context = 'A reader selected some text and the app suggests one action for it.';

// Runs when the reader selects text, and returns the action to show next to Quote, or null.
// maker is the MediaPipe Decision Maker, already loaded.
async function suggestAction( selected ) {
	const answer = await maker.evaluateChoice( `Selected text: "${selected}"`, {
		context,
		instructions: 'Which action fits the selected text?',
		options: [
			{
				label: 'create_task',
				description: 'Work someone must do, a problem to solve, a to-do or assignment',
			},
			{
				label: 'save_in_calendar',
				description: 'A meeting, event or appointment with a date and time',
			},
			{
				label: 'set_reminder',
				description: 'A follow-up later, remember to check back or reply',
			},
			{
				label: 'none',
				description: 'No action fits, just thanks, chatter, news or several different actions',
			},
		],
	} );

	if ( answer.selectedKey !== 'none' && answer.probabilities[ answer.selectedKey ] >= MIN_PROBABILITY ) {
		return answer.selectedKey;
	}
	return null;
}

// server.js
const context = 'A reader selected some text and the app suggests one action for it.';

const { selected } = req.body;
const labels = [ 'create_task', 'save_in_calendar', 'set_reminder', 'none' ];

// gemini is the GoogleGenAI client, set up with your API key.
const interaction = await gemini.interactions.create( {
	model: 'gemini-3.5-flash-lite',
	system_instruction: [
		context,
		'Which action fits the selected text? Pick one action:',
		'create_task: Work someone must do, a problem to solve, a to-do or assignment',
		'save_in_calendar: A meeting, event or appointment with a date and time',
		'set_reminder: A follow-up later, remember to check back or reply',
		'none: No action fits, just thanks, chatter, news or several different actions',
	].join( '\n' ),
	input: `Selected text: "${selected}"`,
	response_format: {
		type: 'text',
		mime_type: 'application/json',
		schema: {
			type: 'object',
			properties: { action: { type: 'string', enum: labels } },
			required: [ 'action' ],
		},
	},
	generation_config: { thinking_level: 'minimal' },
	store: false,
} );
const reply = interaction.status === 'completed' && interaction.output_text
	? JSON.parse( interaction.output_text )
	: null;

if ( labels.includes( reply?.action ) && reply.action !== 'none' ) {
	res.json( { action: reply.action } );
} else {
	res.json( { action: null } );
}

// server.js
// Not measured on gpt-6-luna. Tune it with your own selections.
const MIN_PROBABILITY = 0.5;

const context = 'A reader selected some text and the app suggests one action for it.';

const { selected } = req.body;
const state = { selectedText: selected };

// openai is the OpenAI client, set up with your API key.
const decision = await openai.decisions.create( {
	model: 'gpt-6-luna',
	input: [ { role: 'user', content: [ { type: 'input_json', data: state } ] } ],
	questions: [
		{
			type: 'choice',
			name: 'action',
			instructions: `${context} Which action fits the selected text?`,
			choices: [
				{
					value: 'create_task',
					description: 'Work someone must do, a problem to solve, a to-do or assignment',
				},
				{
					value: 'save_in_calendar',
					description: 'A meeting, event or appointment with a date and time',
				},
				{
					value: 'set_reminder',
					description: 'A follow-up later, remember to check back or reply',
				},
				{
					value: 'none',
					description: 'No action fits, just thanks, chatter, news or several different actions',
				},
			],
		},
	],
} );
const answer = decision.answers.find( ( a ) => a.name === 'action' );
const chosen = answer?.type === 'choice'
	? answer.probabilities.find( ( p ) => p.value === answer.choice )
	: undefined;

if ( chosen && chosen.value !== 'none' && chosen.probability >= MIN_PROBABILITY ) {
	res.json( { action: chosen.value } );
} else {
	res.json( { action: null } );
}

// server.js
const context = 'A reader selected some text and the app suggests one action for it.';

const { selected } = req.body;
const labels = [ 'create_task', 'save_in_calendar', 'set_reminder', 'none' ];

// claude is the Anthropic client, set up with your API key.
const response = await claude.messages.create( {
	model: 'claude-haiku-5-5',
	max_tokens: 1024,
	thinking: { type: 'disabled' },
	system: [
		context,
		'Which action fits the selected text? Pick one action:',
		'create_task: Work someone must do, a problem to solve, a to-do or assignment',
		'save_in_calendar: A meeting, event or appointment with a date and time',
		'set_reminder: A follow-up later, remember to check back or reply',
		'none: No action fits, just thanks, chatter, news or several different actions',
	].join( '\n' ),
	messages: [ { role: 'user', content: `Selected text: "${selected}"` } ],
	output_config: {
		effort: 'low',
		format: {
			type: 'json_schema',
			schema: {
				type: 'object',
				properties: { action: { type: 'string', enum: labels } },
				required: [ 'action' ],
				additionalProperties: false,
			},
		},
	},
} );
const text = response.stop_reason === 'end_turn'
	? response.content.find( ( block ) => block.type === 'text' )?.text
	: null;
const reply = text ? JSON.parse( text ) : null;

if ( labels.includes( reply?.action ) && reply.action !== 'none' ) {
	res.json( { action: reply.action } );
} else {
	res.json( { action: null } );
}

// server.js
import { choice } from '@typesafe-ai/sdk';

// Set from the cost of a wrong guess, then checked on jev-1.14.0 with my test selections.
const MIN_PROBABILITY = 0.5;

const context = 'A reader selected some text and the app suggests one action for it.';

const { selected } = req.body;

// jev is the TypeSafeClient, set up with your API key.
const { answers } = await jev.systemOne( {
	model: 'jev-1.14.0',
	state: { selectedText: selected },
	questions: {
		action: choice(
			`${context} Which action fits the selected text?`,
			{
				create_task: 'Work someone must do, a problem to solve, a to-do or assignment',
				save_in_calendar: 'A meeting, event or appointment with a date and time',
				set_reminder: 'A follow-up later, remember to check back or reply',
				none: 'No action fits, just thanks, chatter, news or several different actions',
			},
		),
	},
} );
const { action } = answers;

if ( action.choice !== 'none' && action.probabilities[ action.choice ] >= MIN_PROBABILITY ) {
	res.json( { action: action.choice } );
} else {
	res.json( { action: null } );
}