@formio/uag-sdk 0.0.0-stage → 2.0.0-rc.10

package/LICENSE.txt

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+Copyright (c) 2025 Form.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,163 @@
-# Temporary Holding Version
+# @formio/uag-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<sub>[Form.io UAG](https://github.com/formio/uag/blob/v2.0.0-rc.8/README.md) &rsaquo; [Engines](https://github.com/formio/uag/blob/v2.0.0-rc.8/README.md#engines-and-routing) &rsaquo; this page</sub>
+
+Build engine packages for the Form.io Universal Agent Gateway (UAG). This package contains:
+
+- the engine contract's types, and `ENGINE_API_VERSION`;
+- `defineEngine`, to declare an engine type and its settings;
+- `EngineError`, for messages that are safe to show to API callers;
+- the loader, which the UAG, `uag-eval` and the engine server use to find, configure and create engines;
+- shared helpers for model APIs with structured outputs;
+- a conformance check that runs from any test runner.
+
+An engine package depends on this package only. It never needs `@formio/uag`.
+
+## An engine package
+
+Name the package `@formio/uag-<type>` (official engines) or `uag-engine-<type>` (anyone's). Export one engine type definition. It is a plugin of type `"engine"`: `name` is the type name used in `UAG_ENGINES`, `title` (default: `name`) is shown to people, and `version` defaults to your package's own version:
+
+```js
+const { defineEngine, EngineError, ENGINE_API_VERSION, requiredSchema } = require('@formio/uag-sdk');
+
+module.exports = defineEngine({
+    type: 'engine',
+    name: 'acme',
+    title: 'Acme',
+    kinds: ['agent'],
+    apiVersion: ENGINE_API_VERSION,
+    settings: {
+        apiKey: { env: 'ACME_API_KEY', required: true, secret: true },
+        model: { env: 'ACME_MODEL', default: 'acme-large-2026-09-01' },
+        maxTokens: { env: 'ACME_MAX_TOKENS', type: 'number', default: 4000 },
+    },
+    create({ name, settings }) {
+        const client = new AcmeClient({ apiKey: settings.apiKey });
+        return {
+            name,
+            kind: 'agent',
+            apiVersion: ENGINE_API_VERSION,
+            model: settings.model,
+            async extract(request) {
+                request.signal?.throwIfAborted();
+                const { schema, decode } = requiredSchema(request.schema);
+                const answer = await client.complete({ schema, signal: request.signal /* ... */ });
+                if (answer.quotaExceeded) throw new EngineError('Quota exceeded for this API key.');
+                return { model: answer.model, values: decode(answer.json) };
+            },
+        };
+    },
+});
+```
+
+The engine must use the instance `name` it is given, and one of the `kinds` it declares. A decision engine has `decide` and `maxOptions`; an agent engine has `extract`, and sets `toolUse: true` when `extract` accepts read-only research tools. See `contract.d.ts` for every request and response.
+
+A definition in the shape of the 2.0 release candidates, with the engine's name in `type` (`{ type: 'acme', kinds, ... }`), is refused with a message showing the shape above.
+
+### Generating text over documents
+
+An agent engine may also implement `generate(request)`, which document plugins call to write free text over uploaded documents, and declare `accepts`, the document kinds it reads natively (default `['text']`; list `'pdf'` only when your model reads PDFs as documents):
+
+```js
+accepts: ['text', 'pdf'],
+async generate({ instructions, system, attachments, format, maxTokens, signal, onProgress }) {
+    // attachments: { kind: 'pdf', data: Buffer, label, pages? } or { kind: 'text', text, label, textFormat? }
+    // Put the documents before the instructions; report progress as the answer streams.
+    return { text, model, stopReason: 'end' /* or 'max_tokens' when cut off */, usage };
+},
+```
+
+`generate` must honour `signal`, never log the documents, and report a truncated answer as `stopReason: 'max_tokens'` rather than failing.
+
+`create` receives `{ name, settings, options, config, requireSetting }`:
+
+- `settings`: the instance's value for each declared setting that has one.
+- `options`: the instance's options as given in configuration, including ones that are not settings, such as a fake client in tests.
+- `config`: the host's configuration, read-only, for example `routing.timeouts[name]`.
+- `requireSetting(key)`: a setting's value, or the standard "needs its setting" error, for a setting that is required only sometimes.
+
+`create` may be async.
+
+## Settings
+
+Each setting is resolved from the first of these that is set:
+
+1. the instance's options in configuration;
+2. `UAG_ENGINE_<NAME>_<SETTING>`, from the instance name and the setting name (`fast` and `apiKey` give `UAG_ENGINE_FAST_API_KEY`);
+3. the variables the setting lists in `env`, in order;
+4. its `default`.
+
+| Key | Meaning |
+|---|---|
+| `env` | The type's own variables, as a name or a list. |
+| `required` | Startup fails without a value. The error names the instance, the type, the setting and every variable that sets it. |
+| `secret` | The value is kept out of startup errors and capability discovery. Errors an engine throws while it runs are logged as they are, so never put a setting's value in one. |
+| `type` | `string` (the default), `number` or `boolean`. Values from the environment are converted. |
+| `default` | Used when nothing else is set. |
+
+## Instances
+
+Hosts enable engines as named instances of a type:
+
+```
+UAG_ENGINES=jev,fast:claude,deep:claude,x:@acme/uag-engine-x
+```
+
+- A bare entry (`jev`) names an instance after its type.
+- `<name>:<type>` names it yourself, so one type can run as several instances with different settings.
+- A type starting with `@` or `uag-engine-`, or containing `/`, is a package name. A bare package entry takes the package's type name.
+- Names use lowercase letters, digits and `-`, start with a letter, and are at most 63 characters. Anything else, including any path, is refused before anything is loaded.
+
+In configuration, an entry is such a string, or `{ name, type, options }`, where `type` may also be an engine type definition.
+
+## Loading
+
+```js
+const { engineInstances } = require('@formio/uag-sdk');
+const { enginePaths, loadEngines } = require('@formio/uag-sdk/loader');
+
+const engines = await loadEngines(engineInstances(config, process.env), {
+    types: { remote: RemoteEngine },        // built-in and embedded types, tried first
+    paths: enginePaths(__dirname, process.env),
+    env: process.env,
+    config,
+});
+```
+
+A type name is looked up in `types`, then as `@formio/uag-<type>`, then as `uag-engine-<type>`. Packages are looked up in the `node_modules` of the host's installation and of the directories above it (where Node finds the host's own dependencies), then in `<dir>/node_modules` of each absolute directory in `UAG_ENGINE_PATH`. Never in the working directory, `NODE_PATH` or Node's global folders, and a package whose entry point resolves outside its own directory is refused. Nothing is ever installed. Engine packages are loaded with `require()`: CommonJS, or ES modules on Node 22.12 or later. Each result is `{ engine, type, package, version }`, which is what `Formflow.engineRegistry` takes.
+
+Every definition is checked structurally, so a package built with another copy of this SDK, or with none, loads too. A package built for another engine contract version is refused, and the error names both versions.
+
+## Errors
+
+Throw `EngineError` for a failure whose message the caller may see, such as "Quota exceeded for this API key." Any other error is reported to API callers only as "the engine failed (see the logs for request X)", because provider SDK errors can carry URLs and account details.
+
+## Helpers
+
+- `requiredSchema(schema)`: the extraction schema with every field required, for strict structured outputs, and `decode(answer)` to map the answer back. An empty value stands for "not stated" and is left out. Numbers and yes/no fields travel as strings, keeping the field's title and description; a number written as an amount (`$4,250`) decodes to 4250, and anything else that is not a number is left out. A typed enum keeps its values, and an answer outside them is dropped.
+- `parseJsonObject(text)`: the first JSON object in a text answer, or an `EngineError`.
+- `toolResultText(result)`: a tool call's result as text for a model.
+
+## Conformance
+
+```js
+const { checkEngine } = require('@formio/uag-sdk/conformance');
+
+it('meets the engine contract', async () => {
+    const report = await checkEngine(require('..'), { options: { client: fakeClient } });
+    assert.deepStrictEqual(report.failures, []);
+});
+```
+
+The check creates an instance and calls it. Pass options, such as a fake client, or the environment variables that let it answer. It checks that:
+
+- the definition and the engine have the contract's shape;
+- the engine uses the instance name and the `model` option;
+- `extract` returns only the fields it was asked about, or `decide` only the questions it was asked;
+- `accepts`, when set, lists only `text` and `pdf`; `generate`, when present, returns text, its model and a valid `stopReason`;
+- research stops at `maxIterations`, and reports every tool call it made;
+- an aborted signal stops the engine, including during research and `generate`.
+
+A research round is the calls a model makes together; calls made one after another count as separate rounds.
+
+License: MIT.

package/conformance.d.ts

@@ -0,0 +1,31 @@
+import type { EngineTypeDefinition } from './index';
+import type { DecisionQuestion, DecisionState, FieldSpec, ToolDefinition } from './contract';
+
+export type ConformanceResult = { check: string; ok: boolean; skipped?: boolean; message?: string };
+
+export type ConformanceReport = {
+    ok: boolean;
+    /** "<check>: <why>" for each failed check. */
+    failures: string[];
+    results: ConformanceResult[];
+};
+
+/** Check an engine type against the engine contract, from any test runner. */
+export declare function checkEngine(definition: EngineTypeDefinition, options?: {
+    /** The instance name to create. Default: "conformance". */
+    name?: string;
+    /** The instance's options, such as a fake client. */
+    options?: Record<string, any>;
+    env?: Record<string, string | undefined>;
+    config?: Record<string, any>;
+    /** How long each call may take, in milliseconds. Default: 10000. */
+    timeout?: number;
+}): Promise<ConformanceReport>;
+
+/** The fixed inputs the check sends, for an engine's own tests and fakes. */
+export declare const STATE: DecisionState;
+export declare const FIELDS: FieldSpec[];
+export declare const SCHEMA: Record<string, any>;
+export declare const QUESTIONS: Record<string, DecisionQuestion>;
+/** The research tool the check offers. */
+export declare const LOOKUP: ToolDefinition;

package/conformance.js

@@ -0,0 +1,291 @@
+'use strict';
+const { ENGINE_API_VERSION, definitionProblems } = require('./define');
+const { createEngine } = require('./loader');
+
+/**
+ * A conformance check for engine types, usable from any test runner:
+ *
+ *   const { checkEngine } = require('@formio/uag-sdk/conformance');
+ *   const report = await checkEngine(MyEngine, { options: { client: fakeClient } });
+ *   assert.deepEqual(report.failures, []);
+ *
+ * It creates an instance and calls it, so pass options (a fake client, say) or
+ * environment variables that let the engine answer. With a real model the
+ * answers vary, so the checks test the contract, not the content.
+ */
+
+const STATE = {
+    instructions: 'Fill in the fields from the notes.',
+    input: { Notes: 'My name is Ada Lovelace and I live in London.' },
+    today: 'Thursday, October 22, 2026 (2026-10-22)',
+};
+
+const FIELDS = [
+    { path: 'name', label: 'Name', type: 'textfield', description: 'The person\'s full name.', rule: 'Plain text.' },
+    { path: 'city', label: 'City', type: 'textfield', description: 'Where the person lives.', rule: 'Plain text.' },
+];
+
+const SCHEMA = { type: 'object', properties: { name: { type: 'string' }, city: { type: 'string' } } };
+
+const LOOKUP = {
+    name: 'lookup',
+    description: 'Look up more notes about the person. Results come in pages.',
+    inputSchema: { type: 'object', properties: { page: { type: 'number' } } },
+};
+
+const QUESTIONS = {
+    colour: { type: 'choice', instructions: 'Which colour does the input mention?', options: { Red: 'The colour red.', Blue: null } },
+    size: { type: 'score', instructions: 'How large is the request?', levels: ['Small', 'Medium', 'Large'] },
+    urgent: { type: 'noul', instructions: 'Is the request urgent?' },
+};
+
+function extractRequest(extra = {}) {
+    return { instructions: STATE.instructions, state: STATE, fields: FIELDS, schema: SCHEMA, ...extra };
+}
+
+function fail(message) {
+    throw new Error(message);
+}
+
+function isProbability(value) {
+    return typeof value === 'number' && value >= 0 && value <= 1;
+}
+
+/** Settle within `ms`, or fail saying what did not finish. */
+function within(ms, promise, what) {
+    let timer;
+    return Promise.race([
+        promise.finally(() => clearTimeout(timer)),
+        new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(new Error(`${what} did not settle within ${ms}ms`)), ms);
+        }),
+    ]);
+}
+
+async function rejects(promise, what) {
+    try {
+        await promise;
+    }
+    catch {
+        return;
+    }
+    fail(`${what} resolved instead of rejecting`);
+}
+
+function checkUsage(response) {
+    if (response.usage === undefined) return;
+    for (const key of ['inputTokens', 'outputTokens']) {
+        const value = response.usage[key];
+        if (value !== undefined && value !== null && !(Number.isInteger(value) && value >= 0)) {
+            fail(`usage.${key} must be a whole number, null or absent, not ${JSON.stringify(value)}`);
+        }
+    }
+}
+
+function checkExtractResponse(response, asked) {
+    if (!response || typeof response !== 'object') fail('extract did not return an object');
+    if (typeof response.model !== 'string' || !response.model) fail('the response does not name its model');
+    if (!response.values || typeof response.values !== 'object' || Array.isArray(response.values)) fail('"values" must be an object');
+    const extra = Object.keys(response.values).filter((path) => !asked.includes(path));
+    if (extra.length) fail(`returned values for fields it was not asked about: ${extra.join(', ')}`);
+    checkUsage(response);
+}
+
+function checkAnswer(id, answer, question) {
+    if (!answer || answer.type !== question.type) fail(`the answer to "${id}" must have type "${question.type}"`);
+    if (question.type === 'noul') {
+        if (!isProbability(answer.probability)) fail(`the answer to "${id}" needs a probability from 0 to 1`);
+        return;
+    }
+    if (!answer.probabilities || !Object.values(answer.probabilities).every(isProbability)) {
+        fail(`the answer to "${id}" needs probabilities from 0 to 1`);
+    }
+    if (!isProbability(answer.confidence)) fail(`the answer to "${id}" needs a confidence from 0 to 1`);
+    if (question.type === 'choice' && !Object.keys(question.options).includes(answer.choice)) {
+        fail(`the answer to "${id}" chose ${JSON.stringify(answer.choice)}, which is not one of its options`);
+    }
+    if (question.type === 'score' && !(Number.isFinite(answer.score) && answer.score >= 0 && answer.score <= question.levels.length - 1)) {
+        fail(`the answer to "${id}" needs a score between 0 and ${question.levels.length - 1}`);
+    }
+}
+
+/**
+ * Tools that count research rounds: a call made while no other call is pending,
+ * after one has finished, starts a round. Calls one turn makes together count
+ * once; a turn's calls made one after another count as separate rounds.
+ */
+function lookupTool({ onCall } = {}) {
+    const state = { calls: [], rounds: 0, pending: 0, settled: true };
+    async function callTool(name, args) {
+        if (state.pending === 0 && state.settled) {
+            state.rounds++;
+            state.settled = false;
+        }
+        state.pending++;
+        state.calls.push(name);
+        try {
+            if (onCall) onCall(state);
+            await new Promise((resolve) => setImmediate(resolve));
+            if (name !== LOOKUP.name) {
+                return { content: [{ type: 'text', text: `The tool "${name}" is not available.` }], isError: true };
+            }
+            const page = Number(args && args.page) || 1;
+            return { content: [{ type: 'text', text: `Page ${page} of 9: Ada was born in 1815. Call lookup with page ${page + 1} for more.` }] };
+        }
+        finally {
+            state.pending--;
+            state.settled = true;
+        }
+    }
+    return { state, callTool };
+}
+
+/**
+ * Check an engine type against the engine contract. Resolves to
+ * `{ ok, failures, results }`; `failures` names each failed check and why.
+ */
+async function checkEngine(definition, { name = 'conformance', options = {}, env = process.env, config = {}, timeout = 10000 } = {}) {
+    const results = [];
+    async function check(label, fn) {
+        try {
+            const outcome = await fn();
+            results.push({ check: label, ok: true, ...(outcome === 'skipped' && { skipped: true }) });
+            return true;
+        }
+        catch (err) {
+            results.push({ check: label, ok: false, message: err && err.message });
+            return false;
+        }
+    }
+    const report = () => ({
+        ok: results.every((result) => result.ok),
+        failures: results.filter((result) => !result.ok).map((result) => `${result.check}: ${result.message}`),
+        results,
+    });
+
+    const valid = await check('is a valid engine type definition', () => {
+        const problems = definitionProblems(definition);
+        if (problems.length) fail(problems.join('; '));
+        if (definition.apiVersion !== ENGINE_API_VERSION) {
+            fail(`it was built for engine API version ${definition.apiVersion}; this SDK checks version ${ENGINE_API_VERSION}`);
+        }
+    });
+    if (!valid) return report();
+
+    let engine;
+    const created = await check('creates an engine with the instance name and the contract\'s shape', async () => {
+        engine = await createEngine(definition, { name, options, env, config });
+        if (typeof engine.model !== 'string' || !engine.model) fail('the engine does not name its model');
+        if (engine.apiVersion !== undefined && engine.apiVersion !== ENGINE_API_VERSION) fail(`the engine declares apiVersion ${engine.apiVersion}`);
+        if (engine.kind === 'decision') {
+            if (typeof engine.decide !== 'function') fail('a decision engine needs a decide function');
+            if (!Number.isInteger(engine.maxOptions) || engine.maxOptions < 2) fail('a decision engine needs maxOptions of at least 2');
+        }
+        else if (typeof engine.extract !== 'function') {
+            fail('an agent engine needs an extract function');
+        }
+    });
+    if (!created) return report();
+
+    await check('respects the instance\'s options', async () => {
+        // A definition made without defineEngine may have no settings.
+        const hasModel = !!(definition.settings && definition.settings.model);
+        const other = await createEngine(definition, { name: `${name}-other`, options: { ...options, ...(hasModel && { model: 'conformance-model-1' }) }, env, config });
+        if (hasModel && other.model !== 'conformance-model-1') {
+            fail(`the model option was set to "conformance-model-1" but the engine reports "${other.model}"`);
+        }
+    });
+
+    if (engine.kind === 'agent') {
+        await check('extract answers only the fields it was asked about', async () => {
+            const response = await within(timeout, engine.extract(extractRequest()), 'extract');
+            checkExtractResponse(response, FIELDS.map((field) => field.path));
+        });
+        await check('extract stops when its signal is aborted', async () => {
+            const controller = new AbortController();
+            controller.abort();
+            await within(timeout, rejects(engine.extract(extractRequest({ signal: controller.signal })), 'extract with an aborted signal'), 'extract with an aborted signal');
+        });
+        await check('accepts lists only known document kinds', () => {
+            if (engine.accepts === undefined) return;
+            if (!Array.isArray(engine.accepts) || !engine.accepts.length) fail('accepts must be a non-empty list of "text" and "pdf"');
+            const unknown = engine.accepts.filter((kind) => !['text', 'pdf'].includes(kind));
+            if (unknown.length) fail(`accepts lists unknown kinds: ${unknown.join(', ')}`);
+        });
+        if (typeof engine.generate === 'function') {
+            await check('generate returns text, its model and a valid stopReason', async () => {
+                const response = await within(timeout, engine.generate({
+                    instructions: 'Summarize the attached document in one sentence.',
+                    attachments: [{ kind: 'text', text: 'Ada Lovelace lives in London and works on engines.', label: 'Document 1: notes.txt', textFormat: 'plain' }],
+                    format: 'markdown',
+                    maxTokens: 200,
+                }), 'generate');
+                if (!response || typeof response !== 'object') fail('generate did not return an object');
+                if (typeof response.text !== 'string') fail('the response has no text');
+                if (typeof response.model !== 'string' || !response.model) fail('the response does not name its model');
+                if (!['end', 'max_tokens'].includes(response.stopReason)) fail(`stopReason must be "end" or "max_tokens", not ${JSON.stringify(response.stopReason)}`);
+                checkUsage(response);
+            });
+            await check('generate stops when its signal is aborted', async () => {
+                const controller = new AbortController();
+                controller.abort();
+                await within(timeout, rejects(engine.generate({ instructions: 'Summarize.', format: 'text', signal: controller.signal }), 'generate with an aborted signal'), 'generate with an aborted signal');
+            });
+        }
+        else if (engine.generate !== undefined) {
+            await check('generate is a function', () => fail('generate must be a function when present'));
+        }
+        if (engine.toolUse) {
+            await check('research reports its tool calls and stops at maxIterations', async () => {
+                const { state, callTool } = lookupTool();
+                const response = await within(timeout, engine.extract(extractRequest({ tools: [LOOKUP], callTool, maxIterations: 2 })), 'extract with tools');
+                checkExtractResponse(response, FIELDS.map((field) => field.path));
+                if (!state.calls.length) return 'skipped';
+                if (state.rounds > 2) fail(`it made ${state.rounds} rounds of tool calls with maxIterations 2`);
+                const reported = (response.toolCalls || []).map((call) => call.name);
+                if (reported.length !== state.calls.length || reported.some((call, i) => call !== state.calls[i])) {
+                    fail(`it reported tool calls ${JSON.stringify(reported)} but made ${JSON.stringify(state.calls)}`);
+                }
+            });
+            await check('research stops calling tools when its signal is aborted', async () => {
+                const controller = new AbortController();
+                let callsAtAbort;
+                const { state, callTool } = lookupTool({
+                    onCall: (current) => {
+                        if (callsAtAbort === undefined) {
+                            callsAtAbort = current.calls.length;
+                            controller.abort();
+                        }
+                    },
+                });
+                const outcome = await within(timeout, engine.extract(extractRequest({ tools: [LOOKUP], callTool, maxIterations: 5, signal: controller.signal }))
+                    .then(() => 'resolved', () => 'rejected'), 'extract aborted during research');
+                if (callsAtAbort === undefined) return 'skipped';
+                if (outcome !== 'rejected') fail('extract resolved after its signal was aborted');
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Calls started in the same turn as the aborting one may still run.
+                if (state.rounds > 1) fail(`it started ${state.rounds - 1} more round(s) of tool calls after the abort`);
+            });
+        }
+    }
+    else {
+        await check('decide answers only the questions it was asked, in the contract\'s shapes', async () => {
+            const response = await within(timeout, engine.decide({ state: STATE, questions: QUESTIONS }), 'decide');
+            if (!response || typeof response !== 'object') fail('decide did not return an object');
+            if (typeof response.model !== 'string' || !response.model) fail('the response does not name its model');
+            const answers = response.answers || {};
+            const extra = Object.keys(answers).filter((id) => !QUESTIONS[id]);
+            if (extra.length) fail(`answered questions it was not asked: ${extra.join(', ')}`);
+            for (const [id, answer] of Object.entries(answers)) checkAnswer(id, answer, QUESTIONS[id]);
+            checkUsage(response);
+        });
+        await check('decide stops when its signal is aborted', async () => {
+            const controller = new AbortController();
+            controller.abort();
+            await within(timeout, rejects(engine.decide({ state: STATE, questions: QUESTIONS, signal: controller.signal }), 'decide with an aborted signal'), 'decide with an aborted signal');
+        });
+    }
+    return report();
+}
+
+module.exports = { checkEngine, STATE, FIELDS, SCHEMA, QUESTIONS, LOOKUP };