@formio/uag 2.0.0-rc.1 → 2.0.0-rc.10

package/lib/documents/readers.d.ts

@@ -0,0 +1,19 @@
+import type { PluginRegistry } from '@formio/appserver';
+import type { FormflowFileReader } from '../formflow';
+/** Read a file as text through the converters: its detected type, its text, and its page count when known. */
+export declare function readAsText(registry: PluginRegistry, buffer: Buffer, meta: {
+    name: string;
+    type?: string;
+}, options?: {
+    signal?: AbortSignal;
+}): Promise<{
+    type: string;
+    text: string;
+    pages?: number;
+}>;
+/**
+ * A reader for task file inputs, built from the converters: it accepts a file
+ * whose type has a route to text, and reads it through that route. Task file
+ * inputs therefore read every type the installed converters handle.
+ */
+export declare function converterFileReader(registry: PluginRegistry): FormflowFileReader;

package/lib/documents/readers.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAsText = readAsText;
+exports.converterFileReader = converterFileReader;
+const detect_1 = require("./detect");
+const convert_1 = require("./convert");
+const mime_1 = require("./mime");
+const plugins_1 = require("./plugins");
+/** What a ZIP file is, from its extension: the first bytes cannot tell a Word file from any other ZIP. */
+const ZIP_BY_EXTENSION = {
+    '.docx': mime_1.MIME.docx, '.xlsx': mime_1.MIME.xlsx, '.pptx': mime_1.MIME.pptx,
+    '.odt': 'application/vnd.oasis.opendocument.text', '.ods': 'application/vnd.oasis.opendocument.spreadsheet', '.odp': 'application/vnd.oasis.opendocument.presentation'
+};
+const log = {
+    info: () => undefined,
+    warn: (msg) => console.warn(`[formio-uag] ${msg}`),
+    error: (msg) => console.error(`[formio-uag] ${msg}`)
+};
+/** Read a file as text through the converters: its detected type, its text, and its page count when known. */
+async function readAsText(registry, buffer, meta, options = {}) {
+    const converters = registry.list('converter');
+    const type = (0, detect_1.identify)(buffer, { name: meta.name, type: meta.type }, converters);
+    const steps = (0, plugins_1.documentsOf)(registry).routes.toText(type);
+    if (!steps) {
+        throw new Error(`"${meta.name}" (${type}) cannot be read as text: no installed converter reads it.`);
+    }
+    const output = await (0, convert_1.runRoute)(steps, { buffer, type, name: meta.name }, 'text', {
+        log,
+        signal: options.signal,
+        settingsOf: (converter) => registry.settings('converter', converter.name)
+    });
+    // No text, with the converters saying why (an image, a scan): an error, never an empty document.
+    if (!String(output.text).trim() && Array.isArray(output.warnings) && output.warnings.length) {
+        throw new convert_1.ConversionError(`"${meta.name}" has no text to read: ${output.warnings.join(' ')}`);
+    }
+    return { type, text: output.text, ...(Array.isArray(output.pages) && { pages: output.pages.length }) };
+}
+/**
+ * A reader for task file inputs, built from the converters: it accepts a file
+ * whose type has a route to text, and reads it through that route. Task file
+ * inputs therefore read every type the installed converters handle.
+ */
+function converterFileReader(registry) {
+    const converters = () => registry.list('converter');
+    return {
+        name: 'converters',
+        accepts(meta, head) {
+            let type;
+            try {
+                type = (0, detect_1.identify)(head, { name: meta.name, type: meta.type }, converters());
+            }
+            catch {
+                // Too few bytes to be sure, or a name that contradicts them: read() decides on the whole file.
+                return true;
+            }
+            if (type === mime_1.MIME.zip)
+                type = ZIP_BY_EXTENSION[(0, mime_1.extensionOf)(meta.name)] || type;
+            return !!(0, plugins_1.documentsOf)(registry).routes.toText(type);
+        },
+        async read(buffer, meta, options) {
+            return { text: (await readAsText(registry, buffer, meta, { signal: options?.signal })).text };
+        }
+    };
+}

package/lib/documents/routes.d.ts

@@ -0,0 +1,52 @@
+import type { Converter, Representation } from './types';
+/** How one file reaches the representations of one of a plugin's input sets. */
+export type FileRoute = {
+    inputs: Representation[];
+    /** The converters that make the PDF ([] for a PDF: identity). */
+    pdf?: Converter[];
+    /** The converters that make the text; with a PDF in the set, the PDF's own steps then PDF to text. */
+    text?: Converter[];
+};
+/** Converter pins by source type: a component's `uag.converters`. */
+export type Pins = Record<string, string>;
+/** A source type a document plugin can take, as its manifest's `accept` lists it. */
+export type AcceptEntry = {
+    type: string;
+    ext: string[];
+    /** The input set it reaches, and the converter names of each representation's route. */
+    routes: {
+        inputs: Representation[];
+        pdf?: string[];
+        text?: string[];
+    };
+    /** The converters that read this type: a pin chooses among them when there are several. */
+    converters: string[];
+};
+/** A converter as `name@version`, as results record routes. */
+export declare const stepName: (converter: Converter) => string;
+/**
+ * Routes from source types to representations over a set of converters.
+ * When several converters can do a step, the component's pin wins, then the
+ * operator's `documents.prefer`, then the highest rank, then the name.
+ */
+export declare class ConverterRoutes {
+    readonly converters: Converter[];
+    private readonly prefer;
+    constructor(converters: Converter[], prefer?: Record<string, string>);
+    /** The converter for one step from `source` to `target`, or undefined when none can do it. */
+    choose(source: string, target: Representation, pins?: Pins): Converter | undefined;
+    /** The steps from `source` to a PDF: [] for a PDF, one converter otherwise, or null. */
+    toPdf(source: string, pins?: Pins): Converter[] | null;
+    /** The steps from `source` to text: one converter, or to a PDF and then its text; null when none. */
+    toText(source: string, pins?: Pins): Converter[] | null;
+    /**
+     * The first of a plugin's input sets every representation of which the
+     * file can reach. With both PDF and text, the text is always that same
+     * PDF's text, so content made from the PDF is checked against it.
+     */
+    route(source: string, inputs: Representation[][], pins?: Pins): FileRoute | null;
+    /** Every source type a converter reads, and PDF. */
+    sourceTypes(): string[];
+    /** The source types a plugin with these inputs can take, with their routes: its manifest's `accept`. */
+    accept(inputs: Representation[][]): AcceptEntry[];
+}

package/lib/documents/routes.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterRoutes = exports.stepName = void 0;
+const mime_1 = require("./mime");
+const detect_1 = require("./detect");
+/** A converter as `name@version`, as results record routes. */
+const stepName = (converter) => `${converter.name}@${converter.version}`;
+exports.stepName = stepName;
+/**
+ * Routes from source types to representations over a set of converters.
+ * When several converters can do a step, the component's pin wins, then the
+ * operator's `documents.prefer`, then the highest rank, then the name.
+ */
+class ConverterRoutes {
+    constructor(converters, prefer = {}) {
+        this.converters = converters;
+        this.prefer = prefer;
+    }
+    /** The converter for one step from `source` to `target`, or undefined when none can do it. */
+    choose(source, target, pins = {}) {
+        const candidates = this.converters.filter((converter) => converter.produces.includes(target) && converter.accepts.some((accept) => accept.type === source));
+        if (!candidates.length)
+            return undefined;
+        for (const preferred of [pins[source], this.prefer[source]]) {
+            const found = preferred && candidates.find((converter) => converter.name === preferred);
+            if (found)
+                return found;
+        }
+        return [...candidates].sort((a, b) => ((b.rank || 0) - (a.rank || 0)) || a.name.localeCompare(b.name))[0];
+    }
+    /** The steps from `source` to a PDF: [] for a PDF, one converter otherwise, or null. */
+    toPdf(source, pins = {}) {
+        if (source === mime_1.MIME.pdf)
+            return [];
+        const converter = this.choose(source, 'pdf', pins);
+        return converter ? [converter] : null;
+    }
+    /** The steps from `source` to text: one converter, or to a PDF and then its text; null when none. */
+    toText(source, pins = {}) {
+        const direct = this.choose(source, 'text', pins);
+        if (direct)
+            return [direct];
+        const pdf = this.toPdf(source, pins);
+        const fromPdf = pdf && this.choose(mime_1.MIME.pdf, 'text', pins);
+        return pdf && fromPdf ? [...pdf, fromPdf] : null;
+    }
+    /**
+     * The first of a plugin's input sets every representation of which the
+     * file can reach. With both PDF and text, the text is always that same
+     * PDF's text, so content made from the PDF is checked against it.
+     */
+    route(source, inputs, pins = {}) {
+        for (const set of inputs) {
+            if (set.includes('pdf')) {
+                const pdf = this.toPdf(source, pins);
+                if (!pdf)
+                    continue;
+                if (!set.includes('text'))
+                    return { inputs: set, pdf };
+                const fromPdf = this.choose(mime_1.MIME.pdf, 'text', pins);
+                if (!fromPdf)
+                    continue;
+                return { inputs: set, pdf, text: [...pdf, fromPdf] };
+            }
+            if (set.includes('text')) {
+                const text = this.toText(source, pins);
+                if (text)
+                    return { inputs: set, text };
+            }
+        }
+        return null;
+    }
+    /** Every source type a converter reads, and PDF. */
+    sourceTypes() {
+        return [...new Set([mime_1.MIME.pdf, ...mime_1.TEXT_TYPES.filter((type) => this.converters.some((c) => c.accepts.some((a) => a.type === type))),
+                ...this.converters.flatMap((converter) => converter.accepts.map((accept) => accept.type))])];
+    }
+    /** The source types a plugin with these inputs can take, with their routes: its manifest's `accept`. */
+    accept(inputs) {
+        const entries = [];
+        for (const type of this.sourceTypes()) {
+            const route = this.route(type, inputs);
+            if (!route)
+                continue;
+            entries.push({
+                type,
+                ext: (0, detect_1.extensionsOf)(type, this.converters),
+                routes: {
+                    inputs: route.inputs,
+                    ...(route.pdf && { pdf: route.pdf.map((c) => c.name) }),
+                    ...(route.text && { text: route.text.map((c) => c.name) })
+                },
+                converters: this.converters.filter((c) => c.accepts.some((a) => a.type === type)).map((c) => c.name)
+            });
+        }
+        return entries;
+    }
+}
+exports.ConverterRoutes = ConverterRoutes;

package/lib/documents/types.d.ts

@@ -0,0 +1,126 @@
+import type { Plugin, PluginContext } from '@formio/appserver';
+import type { GenerateRequest, GenerateResponse } from '@formio/uag-sdk';
+export type Representation = 'pdf' | 'text';
+export type TextFormat = 'plain' | 'markdown' | 'csv';
+/** Plugin type `converter` (apiVersion 1, experimental): a file into a PDF or text. */
+export interface Converter extends Plugin {
+    type: 'converter';
+    /** MIME types (canonical) and extensions it reads. */
+    accepts: Array<{
+        type: string;
+        ext?: string[];
+    }>;
+    produces: Representation[];
+    /** Default 0; the higher wins when several converters can do a step. */
+    rank?: number;
+    /** A canonical type for formats the shared detection does not know, or null. */
+    detect?(head: Buffer, hint: {
+        name: string;
+        type: string;
+    }): string | null;
+    /** Defaults: 25 MB, 120000 ms, 2 at a time. */
+    limits?: {
+        maxBytes?: number;
+        timeoutMs?: number;
+        concurrency?: number;
+    };
+    convert(input: {
+        buffer: Buffer;
+        type: string;
+        name: string;
+    }, options: {
+        to: Representation;
+        settings: Record<string, any>;
+        signal: AbortSignal;
+        tmpdir: string;
+        log: PluginContext['log'];
+    }): Promise<ConverterOutput>;
+}
+export type ConverterOutput = {
+    pdf: Buffer;
+    pages?: number;
+    warnings?: string[];
+} | {
+    text: string;
+    textFormat: TextFormat;
+    pages?: Array<{
+        page: number;
+        text: string;
+    }>;
+    warnings?: string[];
+};
+export type DocumentFile = {
+    name: string;
+    type: string;
+    size: number;
+    sha256: string;
+    document: {
+        pdf?: Buffer;
+        pages?: number;
+        text?: string;
+        textFormat?: string;
+        textPages?: Array<{
+            page: number;
+            text: string;
+        }>;
+    };
+    /** The converters it went through, as name@version. */
+    route: string[];
+    original(): Promise<Buffer>;
+};
+export type DocumentContext = {
+    files: DocumentFile[];
+    /** Markdown. */
+    instructions: string;
+    /** This component's plugin settings, defaults applied. */
+    settings: Record<string, any>;
+    /** Operator settings. */
+    config: Record<string, any>;
+    form: {
+        id: string;
+        path: string;
+        title: string;
+    };
+    component: {
+        key: string;
+        path: string;
+        label: string;
+    };
+    /** Submission data sent with the request: context only, untrusted. */
+    data: Record<string, any>;
+    agent: {
+        generate(request: Omit<GenerateRequest, 'signal'>): Promise<GenerateResponse>;
+    };
+    progress(fraction: number, message?: string): void;
+    signal: AbortSignal;
+    log: PluginContext['log'];
+};
+export type Issue = {
+    kind: string;
+    message: string;
+    output?: string;
+    document?: string;
+    page?: number;
+    file?: string;
+};
+export type DocumentResult = {
+    content: string;
+    status: 'ok' | 'flagged';
+    issues?: Issue[];
+    summary?: string;
+};
+/** Plugin type `document` (apiVersion 1, experimental): files and instructions into content. */
+export interface DocumentPlugin extends Plugin {
+    type: 'document';
+    /** Acceptable representation sets, in order of preference. */
+    inputs: Representation[][];
+    /** JSON only; keys are relative to the plugin's settings object. */
+    editForm?: any[];
+    defaults?: Record<string, any>;
+    /** May people edit the content? Default false. */
+    editable?: boolean;
+    /** Default 'markdown'. */
+    output?: 'markdown' | 'text';
+    validateSettings?(settings: Record<string, any>): string[];
+    process(ctx: DocumentContext): Promise<DocumentResult>;
+}

package/lib/documents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/documents/uagJs.d.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import type { PluginRegistry, ServedComponent } from '@formio/appserver';
+/**
+ * `@formio/uag-js` from the UAG's own installation, at stable URLs (never a
+ * version in the path: the portal remembers its one-time prompt by URL):
+ *
+ * - `/uag-js/uag.use.js`: the bundle, registering itself with this UAG's URL and the manifest;
+ * - `/uag-js/portal.js`: the same in portal mode (the component only), then `?chain=` (https only);
+ * - `/uag-js/portal.css`: the stylesheet, after `@import url(<chain>)` when `?chain=` is given;
+ * - `/uag-js/uag-js.css`: the stylesheet.
+ *
+ * The modules' components come after: each script after the registration in
+ * `uag.use.js` and `portal.js`, each stylesheet after `uag-js.css` (and in
+ * `portal.css`), and each on its own at `/uag-js/components/<type>.js|css`.
+ * They are read on every request, as the bundle is, so the ETag follows them.
+ */
+export declare function uagJsRouter(registry: () => PluginRegistry | undefined, components?: () => ServedComponent[]): Router;

package/lib/documents/uagJs.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uagJsRouter = uagJsRouter;
+const fs_1 = __importDefault(require("fs"));
+const vm_1 = __importDefault(require("vm"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const express_1 = require("express");
+/** Where @formio/uag-js is installed: as a package, or the UAG's own workspace copy. */
+function uagJsDirectory() {
+    try {
+        return path_1.default.dirname(require.resolve('@formio/uag-js/package.json'));
+    }
+    catch {
+        const local = path_1.default.resolve(__dirname, '..', '..', 'packages', 'uag-js');
+        return fs_1.default.existsSync(path_1.default.join(local, 'index.js')) ? local : undefined;
+    }
+}
+const read = (file) => fs_1.default.readFileSync(path_1.default.join(uagJsDirectory() || '', file), 'utf8');
+/** A chained script or stylesheet URL from `?chain=`, when it is an absolute URL of the allowed schemes. */
+function chainOf(req, schemes) {
+    const chain = typeof req.query.chain === 'string' ? req.query.chain : '';
+    if (!chain)
+        return undefined;
+    try {
+        const url = new URL(chain);
+        return schemes.includes(url.protocol) ? url.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The script that registers the bundle once formio.js is on the page: with
+ * this UAG's URL (from the script's own src) and the manifest, and in portal
+ * mode for the portal script, then loads the chained script over https only.
+ */
+function registration(manifest, options) {
+    return `
+;(function () {
+    var manifest = ${JSON.stringify(manifest).replace(/</g, '\\u003c')};
+    var script = document.currentScript;
+    var src = script && script.src ? new URL(script.src, location.href) : null;
+    var uagUrl = src ? src.href.slice(0, src.href.indexOf('/uag-js/')) : location.origin;
+    function register() {
+        var Formio = window.Formio;
+        var lib = window.FormioUAG;
+        if (!Formio || !lib || typeof Formio.use !== 'function') return false;
+        Formio.use(lib.UAG(uagUrl, { ${options.portal ? 'portal: true, ' : ''}manifest: manifest }));
+        return true;
+    }
+    if (!register()) {
+        var tries = 0;
+        var timer = setInterval(function () { if (register() || ++tries > 600) clearInterval(timer); }, 50);
+    }
+    ${options.chain ? `var chain = document.createElement('script');
+    chain.src = ${JSON.stringify(options.chain)};
+    document.head.appendChild(chain);` : ''}
+})();
+`;
+}
+/** Whether each component script parses as a classic browser script, by its content (checked once per content). */
+const parsed = new Map();
+function parsesAsScript(file, source) {
+    const hash = (0, crypto_1.createHash)('sha256').update(source).digest('base64url');
+    const known = parsed.get(file);
+    if (known?.hash === hash)
+        return known.ok;
+    let ok = true;
+    try {
+        // Compiled only, never run. Wrapped as the bundle wraps it, so the check matches what the browser parses.
+        new vm_1.default.Script(`try {\n${source}\n} catch (err) {}`, { filename: file });
+    }
+    catch {
+        ok = false;
+        console.warn(`[formio-uag] The component script ${file} is not a browser script (an ES module, or a syntax error); it is left out of uag.use.js and portal.js.`);
+    }
+    parsed.set(file, { hash, ok });
+    return ok;
+}
+/** Serve one file: public, revalidated every time (no-cache), with an ETag from its content and the manifest. */
+function serve(req, res, type, body) {
+    const etag = `"${(0, crypto_1.createHash)('sha256').update(body).digest('base64url')}"`;
+    res.set({ 'Content-Type': `${type}; charset=utf-8`, 'Cache-Control': 'no-cache', ETag: etag, 'Access-Control-Allow-Origin': '*' });
+    if (req.headers['if-none-match'] === etag)
+        return res.status(304).end();
+    res.status(200).send(body);
+}
+/**
+ * `@formio/uag-js` from the UAG's own installation, at stable URLs (never a
+ * version in the path: the portal remembers its one-time prompt by URL):
+ *
+ * - `/uag-js/uag.use.js`: the bundle, registering itself with this UAG's URL and the manifest;
+ * - `/uag-js/portal.js`: the same in portal mode (the component only), then `?chain=` (https only);
+ * - `/uag-js/portal.css`: the stylesheet, after `@import url(<chain>)` when `?chain=` is given;
+ * - `/uag-js/uag-js.css`: the stylesheet.
+ *
+ * The modules' components come after: each script after the registration in
+ * `uag.use.js` and `portal.js`, each stylesheet after `uag-js.css` (and in
+ * `portal.css`), and each on its own at `/uag-js/components/<type>.js|css`.
+ * They are read on every request, as the bundle is, so the ETag follows them.
+ */
+function uagJsRouter(registry, components = () => []) {
+    const router = (0, express_1.Router)();
+    const manifest = () => {
+        const plugins = registry();
+        // Every plugin the modules' components may read (document, converter, module, and types
+        // modules define): not the UAG's own engines, tools and actions, which /plugins lists.
+        return plugins ? plugins.manifest().filter((plugin) => !['engine', 'tool', 'action'].includes(plugin.type)) : [];
+    };
+    // Each component's script in its own try/catch, so one that fails when it runs does not stop the others.
+    // A script that does not parse would break the whole bundle, which try/catch cannot stop: it is left out.
+    const scripts = () => components().map((component) => {
+        const label = `The ${component.type} component of the ${component.module} module`;
+        const source = fs_1.default.readFileSync(component.scriptPath, 'utf8');
+        if (!parsesAsScript(component.scriptPath, source)) {
+            return `\n;/* ${component.module}: ${component.type} */\nconsole.error(${JSON.stringify(`[uag-js] ${label} is not a browser script (an ES module, or a syntax error), so it was left out.`)});\n`;
+        }
+        return `\n;/* ${component.module}: ${component.type} */\ntry {\n${source}\n} catch (err) { console.error(${JSON.stringify(`[uag-js] ${label} could not load:`)}, err); }\n`;
+    }).join('');
+    const styles = () => components().filter((component) => component.stylePath).map((component) => `\n/* ${component.module}: ${component.type} */\n${fs_1.default.readFileSync(component.stylePath, 'utf8')}`).join('');
+    const component = (type) => components().find((candidate) => candidate.type === type);
+    router.get('/uag-js/components/:file', (req, res) => {
+        const match = /^([a-z][a-z0-9]*)\.(js|css)$/.exec(String(req.params.file));
+        const found = match ? component(match[1]) : undefined;
+        const file = found && (match[2] === 'js' ? found.scriptPath : found.stylePath);
+        if (!file)
+            return res.status(404).type('text/plain').send('No module of this UAG has that component.');
+        serve(req, res, match[2] === 'js' ? 'application/javascript' : 'text/css', fs_1.default.readFileSync(file, 'utf8'));
+    });
+    const missing = (res) => res.status(404).type('text/plain').send('@formio/uag-js is not installed with this UAG.');
+    router.get('/uag-js/uag.use.js', (req, res) => {
+        if (!uagJsDirectory())
+            return missing(res);
+        serve(req, res, 'application/javascript', read('index.js') + registration(manifest(), { portal: false }) + scripts());
+    });
+    router.get('/uag-js/portal.js', (req, res) => {
+        if (!uagJsDirectory())
+            return missing(res);
+        serve(req, res, 'application/javascript', read('index.js') + registration(manifest(), { portal: true, chain: chainOf(req, ['https:']) }) + scripts());
+    });
+    router.get('/uag-js/portal.css', (req, res) => {
+        if (!uagJsDirectory())
+            return missing(res);
+        const chain = chainOf(req, ['https:', 'http:']);
+        serve(req, res, 'text/css', (chain ? `@import url(${JSON.stringify(chain)});\n` : '') + read('uag-js.css') + styles());
+    });
+    router.get('/uag-js/uag-js.css', (req, res) => {
+        if (!uagJsDirectory())
+            return missing(res);
+        serve(req, res, 'text/css', read('uag-js.css') + styles());
+    });
+    return router;
+}

package/lib/formflow.d.ts

@@ -1,11 +1,15 @@
-import { Formflow } from '@formio/appserver-core';
+import { Formflow } from '@formio/appserver';
 /**
- * Agentic Formflow from @formio/appserver-core, imported directly rather than
- * through @formio/appserver, under the names the UAG uses. Internal to the UAG:
+ * Agentic Formflow from @formio/appserver-core, through @formio/appserver (see
+ * assertSingleCore), under the names the UAG uses. Internal to the UAG:
  * applications reach Formflow as `Formflow` from this package's exports.
  */
-export declare const EngineConfigError: typeof Formflow.EngineConfigError, EngineRegistry: typeof Formflow.EngineRegistry, FormflowError: typeof Formflow.FormflowError, FormflowService: typeof Formflow.FormflowService, RateLimitError: typeof Formflow.RateLimitError, ScopedTokenError: typeof Formflow.ScopedTokenError, bearerOf: typeof Formflow.bearerOf, engineRegistry: typeof Formflow.engineRegistry, formflow: typeof Formflow.formflow, formflowAuthenticate: typeof Formflow.formflowAuthenticate, identityOf: typeof Formflow.identityOf, issueScopedToken: typeof Formflow.issueScopedToken, isScopedToken: typeof Formflow.isScopedToken, readScopedToken: typeof Formflow.readScopedToken, resolveTaskName: typeof Formflow.resolveTaskName, resultEvent: typeof Formflow.resultEvent, warnLegacy: typeof Formflow.warnLegacy, withoutOwnedValues: typeof Formflow.withoutOwnedValues, stubAgentEngine: typeof Formflow.stubAgentEngine, stubDecisionEngine: typeof Formflow.stubDecisionEngine, toolsForScope: typeof Formflow.toolsForScope, EngineError: typeof Formflow.EngineError, formatReport: typeof Formflow.formatReport;
+export declare const EngineConfigError: typeof Formflow.EngineConfigError, EngineRegistry: typeof Formflow.EngineRegistry, FormflowError: typeof Formflow.FormflowError, FormflowService: typeof Formflow.FormflowService, RateLimitError: typeof Formflow.RateLimitError, ScopedTokenError: typeof Formflow.ScopedTokenError, bearerOf: typeof Formflow.bearerOf, engineRegistry: typeof Formflow.engineRegistry, formflow: typeof Formflow.formflow, formflowAuthenticate: typeof Formflow.formflowAuthenticate, identityOf: typeof Formflow.identityOf, issueScopedToken: typeof Formflow.issueScopedToken, isScopedToken: typeof Formflow.isScopedToken, readScopedToken: typeof Formflow.readScopedToken, resultEvent: typeof Formflow.resultEvent, withoutOwnedValues: typeof Formflow.withoutOwnedValues, callerKey: typeof Formflow.callerKey, stubAgentEngine: typeof Formflow.stubAgentEngine, stubDecisionEngine: typeof Formflow.stubDecisionEngine, toolsForScope: typeof Formflow.toolsForScope, EngineError: typeof Formflow.EngineError, formatReport: typeof Formflow.formatReport, flagOn: typeof Formflow.flagOn, flagOff: typeof Formflow.flagOff, ruleWithConstraints: typeof Formflow.ruleWithConstraints, describeBinary: typeof Formflow.describeBinary, isBinaryComponent: typeof Formflow.isBinaryComponent, fileMeta: typeof Formflow.fileMeta, plainTextReader: Formflow.FormflowFileReader, useDatabase: typeof Formflow.useDatabase, startEngines: typeof Formflow.startEngines, CHAT_INSTRUCTIONS: string, CHAT_REPLY: string, CHAT_CONFIRMED: string, CHAT_CHECK_TOOL: Formflow.ToolDefinition, LEASE_MS: number, RENEW_MS: number, MAX_ATTEMPTS: number;
 export type AgentEngine = Formflow.AgentEngine;
+export type TaskRunStatus = Formflow.TaskRunStatus;
+export type CoreTaskRunRecord<Id> = Formflow.TaskRunRecord<Id>;
+export type CoreNewTaskRun<Id> = Formflow.NewTaskRun<Id>;
+export type CoreTaskRunStore<Id> = Formflow.TaskRunStore<Id>;
 export type CallerIdentity = Formflow.CallerIdentity;
 export type DecisionEngine = Formflow.DecisionEngine;
 export type DecisionRequest = Formflow.DecisionRequest;
@@ -25,6 +29,9 @@ export type FormflowRoutingConfig = Formflow.FormflowRoutingConfig;
 export type FormflowService = Formflow.FormflowService;
 export type FormflowTask = Formflow.FormflowTask;
 export type FormflowTool = Formflow.FormflowTool;
+export type FormflowFileReader = Formflow.FormflowFileReader;
+export type FormflowFileMeta = Formflow.FormflowFileMeta;
+export type FormflowFileContent = Formflow.FormflowFileContent;
 export type OperationContext = Formflow.OperationContext;
 export type OperationResult = Formflow.OperationResult;
 export type ScopedTokenClaims = Formflow.ScopedTokenClaims;

package/lib/formflow.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatReport = exports.EngineError = exports.toolsForScope = exports.stubDecisionEngine = exports.stubAgentEngine = exports.withoutOwnedValues = exports.warnLegacy = exports.resultEvent = exports.resolveTaskName = exports.readScopedToken = exports.isScopedToken = exports.issueScopedToken = exports.identityOf = exports.formflowAuthenticate = exports.formflow = exports.engineRegistry = exports.bearerOf = exports.ScopedTokenError = exports.RateLimitError = exports.FormflowService = exports.FormflowError = exports.EngineRegistry = exports.EngineConfigError = void 0;
+exports.MAX_ATTEMPTS = exports.RENEW_MS = exports.LEASE_MS = exports.CHAT_CHECK_TOOL = exports.CHAT_CONFIRMED = exports.CHAT_REPLY = exports.CHAT_INSTRUCTIONS = exports.startEngines = exports.useDatabase = exports.plainTextReader = exports.fileMeta = exports.isBinaryComponent = exports.describeBinary = exports.ruleWithConstraints = exports.flagOff = exports.flagOn = exports.formatReport = exports.EngineError = exports.toolsForScope = exports.stubDecisionEngine = exports.stubAgentEngine = exports.callerKey = exports.withoutOwnedValues = exports.resultEvent = exports.readScopedToken = exports.isScopedToken = exports.issueScopedToken = exports.identityOf = exports.formflowAuthenticate = exports.formflow = exports.engineRegistry = exports.bearerOf = exports.ScopedTokenError = exports.RateLimitError = exports.FormflowService = exports.FormflowError = exports.EngineRegistry = exports.EngineConfigError = void 0;
 exports.callerIdentity = callerIdentity;
-const appserver_core_1 = require("@formio/appserver-core");
+const appserver_1 = require("@formio/appserver");
 /**
- * Agentic Formflow from @formio/appserver-core, imported directly rather than
- * through @formio/appserver, under the names the UAG uses. Internal to the UAG:
+ * Agentic Formflow from @formio/appserver-core, through @formio/appserver (see
+ * assertSingleCore), under the names the UAG uses. Internal to the UAG:
  * applications reach Formflow as `Formflow` from this package's exports.
  */
-({ EngineConfigError: exports.EngineConfigError, EngineRegistry: exports.EngineRegistry, FormflowError: exports.FormflowError, FormflowService: exports.FormflowService, RateLimitError: exports.RateLimitError, ScopedTokenError: exports.ScopedTokenError, bearerOf: exports.bearerOf, engineRegistry: exports.engineRegistry, formflow: exports.formflow, formflowAuthenticate: exports.formflowAuthenticate, identityOf: exports.identityOf, issueScopedToken: exports.issueScopedToken, isScopedToken: exports.isScopedToken, readScopedToken: exports.readScopedToken, resolveTaskName: exports.resolveTaskName, resultEvent: exports.resultEvent, warnLegacy: exports.warnLegacy, withoutOwnedValues: exports.withoutOwnedValues, stubAgentEngine: exports.stubAgentEngine, stubDecisionEngine: exports.stubDecisionEngine, toolsForScope: exports.toolsForScope, EngineError: exports.EngineError, formatReport: exports.formatReport } = appserver_core_1.Formflow);
+({ EngineConfigError: exports.EngineConfigError, EngineRegistry: exports.EngineRegistry, FormflowError: exports.FormflowError, FormflowService: exports.FormflowService, RateLimitError: exports.RateLimitError, ScopedTokenError: exports.ScopedTokenError, bearerOf: exports.bearerOf, engineRegistry: exports.engineRegistry, formflow: exports.formflow, formflowAuthenticate: exports.formflowAuthenticate, identityOf: exports.identityOf, issueScopedToken: exports.issueScopedToken, isScopedToken: exports.isScopedToken, readScopedToken: exports.readScopedToken, resultEvent: exports.resultEvent, withoutOwnedValues: exports.withoutOwnedValues, callerKey: exports.callerKey, stubAgentEngine: exports.stubAgentEngine, stubDecisionEngine: exports.stubDecisionEngine, toolsForScope: exports.toolsForScope, EngineError: exports.EngineError, formatReport: exports.formatReport, flagOn: exports.flagOn, flagOff: exports.flagOff, ruleWithConstraints: exports.ruleWithConstraints, describeBinary: exports.describeBinary, isBinaryComponent: exports.isBinaryComponent, fileMeta: exports.fileMeta, plainTextReader: exports.plainTextReader, useDatabase: exports.useDatabase, startEngines: exports.startEngines, CHAT_INSTRUCTIONS: exports.CHAT_INSTRUCTIONS, CHAT_REPLY: exports.CHAT_REPLY, CHAT_CONFIRMED: exports.CHAT_CONFIRMED, CHAT_CHECK_TOOL: exports.CHAT_CHECK_TOOL, LEASE_MS: exports.LEASE_MS, RENEW_MS: exports.RENEW_MS, MAX_ATTEMPTS: exports.MAX_ATTEMPTS } = appserver_1.Formflow);
 /**
  * Who an operation's research acts as: core's `identityOf`, and for a caller
  * signed in with a Form.io token (`x-jwt-token`), that token, so a scoped token