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

package/lib/agent/router.js

@@ -34,14 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AGENT_BODY_LIMIT = void 0;
+exports.agentBodyLimit = agentBodyLimit;
+exports.agentEndpoints = agentEndpoints;
 exports.AgentRouter = AgentRouter;
 exports.agentNotFound = agentNotFound;
 exports.agentCredentials = agentCredentials;
 exports.FormAgentRouter = FormAgentRouter;
-const crypto_1 = require("crypto");
 const lodash_1 = require("lodash");
 const express_1 = __importStar(require("express"));
-const protocol_1 = require("@formio/uag-sdk/protocol");
+const errors_1 = require("./errors");
 const formflow_1 = require("../formflow");
 const requestId_1 = require("./requestId");
 const anonymous_1 = require("./anonymous");
@@ -67,10 +68,17 @@ function openStream(res) {
 function contextOf(req) {
     return { auth: req.auth, requestId: req.requestId, identity: (0, formflow_1.callerIdentity)(req.auth, req) };
 }
-/** The task the request names, if any. */
+/**
+ * The task the request names, if any. A request that still names a 1.x
+ * `persona` is refused: ignoring it would run every task, an engine call each.
+ */
 function taskOf(req) {
+    const named = (value) => typeof value === 'string' && value.trim() !== '';
     const task = req.body?.task;
-    return typeof task === 'string' && task ? task : undefined;
+    if (named(req.body?.persona) && !named(task)) {
+        throw new formflow_1.FormflowError(400, 'UAG 2.0 renamed "persona" to "task". Send "task" instead.');
+    }
+    return named(task) ? task : undefined;
 }
 /**
  * Answer extract, streaming per-engine results when the client asks for a
@@ -101,27 +109,37 @@ async function respondWithStream(req, res, run) {
         res.json(done);
     }
 }
-/** The largest request body an agent operation takes, in bytes. */
+/** The largest request body an agent operation takes by default, in bytes. */
 exports.AGENT_BODY_LIMIT = 5 * 1024 * 1024;
+/**
+ * The largest request body the project's agent operations take: `agentApi.bodyLimit`,
+ * then AGENT_BODY_LIMIT, then 5 MB. A document sent inline (a base64 file a task reads)
+ * may need more; the server's own MAX_BODY_SIZE (16 MB) still applies first.
+ */
+function agentBodyLimit(project) {
+    const configured = Number(project.config?.agentApi?.bodyLimit ?? process.env.AGENT_BODY_LIMIT);
+    return Number.isFinite(configured) && configured > 0 ? configured : exports.AGENT_BODY_LIMIT;
+}
 /** The parts every Agent API endpoint shares: the request id, and errors answered as JSON (or as an event mid-stream). */
 function agentEndpoints(project) {
-    const parse = express_1.default.json({ limit: exports.AGENT_BODY_LIMIT });
+    const limit = agentBodyLimit(project);
+    const parse = express_1.default.json({ limit });
     // The server parses JSON bodies first, with its own larger limit, so the
     // agent operations' limit is checked here on a body already read.
     const json = (req, res, next) => {
         if (req.body === undefined)
             return parse(req, res, next);
         const length = Number(req.get('content-length')) || Buffer.byteLength(JSON.stringify(req.body ?? null));
-        if (length > exports.AGENT_BODY_LIMIT) {
-            return res.status(413).json({ error: `The request body is larger than the agent operations' limit of ${exports.AGENT_BODY_LIMIT / (1024 * 1024)} MB.` });
+        if (length > limit) {
+            return res.status(413).json({ error: `The request body is larger than the agent operations' limit of ${Math.round(limit / (1024 * 1024) * 10) / 10} MB.`, code: 'payload_too_large' });
         }
         next();
     };
-    // Request id, after authentication: refused requests carry none. One that
-    // is not a short token is replaced, so it is never echoed, logged or sent on.
+    // The request id, usually assigned already by agentErrorShape, ahead of every
+    // refusal. One that is not a short token is replaced, so it is never echoed,
+    // logged or sent on.
     const requestId = (req, res, next) => {
-        req.requestId = (0, protocol_1.safeRequestId)(req.get('x-request-id')) || (0, crypto_1.randomUUID)();
-        res.set('X-Request-Id', req.requestId);
+        (0, errors_1.requestIdOf)(req, res);
         next();
     };
     const handle = (operation, fn) => async (req, res) => {
@@ -133,19 +151,13 @@ function agentEndpoints(project) {
             await (0, requestId_1.withRequestId)(agentReq.requestId, () => fn(agentReq, res, service));
         }
         catch (err) {
-            const status = err instanceof formflow_1.FormflowError ? err.status : 500;
+            const { status, body } = (0, errors_1.agentError)(agentReq.requestId, err);
             if (status === 500) {
                 debug(`[${agentReq.requestId}] ${operation} failed:`, err);
             }
             if (err instanceof formflow_1.RateLimitError) {
                 res.set('Retry-After', String(Math.ceil(err.retryAfterMs / 1000)));
             }
-            const body = {
-                requestId: agentReq.requestId,
-                error: status === 500 ? 'The request failed. See the UAG logs for this request id.' : err.message,
-                ...(err instanceof formflow_1.FormflowError && err.code && { code: err.code }),
-                ...(err?.edition && { edition: err.edition })
-            };
             if (res.headersSent) {
                 // Mid-stream: report the failure as an event and close.
                 res.write(`event: error\ndata: ${JSON.stringify(body)}\n\n`);
@@ -207,11 +219,11 @@ function agentNotFound(project) {
             : !!formPath && forms.some((form) => String(form.path || '').toLowerCase() === formPath.toLowerCase());
         if (known)
             return next();
-        res.status(404).json({ error: `The form "${byId ? byId[1] : formPath}" does not exist or is not tagged "uag".` });
+        res.status(404).json({ error: `The form "${byId ? byId[1] : formPath}" does not exist or is not tagged "uag".`, code: 'form_not_found' });
     };
 }
-function refuse(res, detail) {
-    return res.status(401).json({ detail });
+function refuse(res, error) {
+    return res.status(401).json({ error, code: 'unauthorized' });
 }
 /**
  * Who may call a form's agent operations, on top of the project's own
@@ -283,10 +295,10 @@ function FormAgentRouter(project, credentials) {
     route('chat', 'chat', async (req, res, service) => {
         const form = await project.formflowForm(formOf(req));
         if (!form) {
-            throw new formflow_1.FormflowError(404, `The form "${formOf(req)}" does not exist or is not tagged "uag".`);
+            throw new formflow_1.FormflowError(404, `The form "${formOf(req)}" does not exist or is not tagged "uag".`, 'form_not_found');
         }
-        if (String(form.form?.properties?.uagChat) === 'false') {
-            throw new formflow_1.FormflowError(403, `Chat is turned off for the form "${form.formflowName}".`);
+        if ((0, formflow_1.flagOff)(form.form?.properties?.uagChat)) {
+            throw new formflow_1.FormflowError(403, `Chat is turned off for the form "${form.formflowName}".`, 'chat_disabled');
         }
         service.requireAccess(req.auth, form, ['create']);
         res.json(await (0, chat_1.chatTurn)(project, form, req.body, { auth: req.auth, requestId: req.requestId }));

package/lib/agent/stubs.d.ts

@@ -1,3 +1,4 @@
+import type { GenerateRequest } from '@formio/uag-sdk';
 /**
  * Stand-in engines for tests and local development. They answer instantly with
  * predictable values, so the Agent API can be exercised end to end without
@@ -6,7 +7,9 @@
  * any instance name.
  */
 export declare const StubDecisionEngine: Readonly<{
-    type: string;
+    type: "engine";
+    name: string;
+    title: string;
     kinds: "decision"[];
     apiVersion: 1;
     description: string;
@@ -14,8 +17,16 @@ export declare const StubDecisionEngine: Readonly<{
         calls: number;
     };
 }>;
+/** How many generate requests the stub agent engines keep: a UAG running them for a demo never grows without bound. */
+export declare const STUB_GENERATE_REQUESTS_KEPT = 20;
+/** The last generate requests the stub agent engines received (STUB_GENERATE_REQUESTS_KEPT), oldest first, for tests. */
+export declare const stubGenerateRequests: Array<Omit<GenerateRequest, 'signal' | 'onProgress'> & {
+    engine: string;
+}>;
 export declare const StubAgentEngine: Readonly<{
-    type: string;
+    type: "engine";
+    name: string;
+    title: string;
     kinds: "agent"[];
     apiVersion: 1;
     description: string;

package/lib/agent/stubs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StubAgentEngine = exports.StubDecisionEngine = void 0;
+exports.StubAgentEngine = exports.stubGenerateRequests = exports.STUB_GENERATE_REQUESTS_KEPT = exports.StubDecisionEngine = void 0;
 const uag_sdk_1 = require("@formio/uag-sdk");
 const formflow_1 = require("../formflow");
 /**
@@ -11,16 +11,29 @@ const formflow_1 = require("../formflow");
  * any instance name.
  */
 exports.StubDecisionEngine = (0, uag_sdk_1.defineEngine)({
-    type: 'stub-decision',
+    type: 'engine',
+    name: 'stub-decision',
+    title: 'Stub decision engine',
     kinds: ['decision'],
     apiVersion: uag_sdk_1.ENGINE_API_VERSION,
     description: 'Answers every decision with a fixed, predictable value. For tests and local development.',
     create: ({ name }) => (0, formflow_1.stubDecisionEngine)({ name }),
 });
+/** How many generate requests the stub agent engines keep: a UAG running them for a demo never grows without bound. */
+exports.STUB_GENERATE_REQUESTS_KEPT = 20;
+/** The last generate requests the stub agent engines received (STUB_GENERATE_REQUESTS_KEPT), oldest first, for tests. */
+exports.stubGenerateRequests = [];
 exports.StubAgentEngine = (0, uag_sdk_1.defineEngine)({
-    type: 'stub-agent',
+    type: 'engine',
+    name: 'stub-agent',
+    title: 'Stub agent engine',
     kinds: ['agent'],
     apiVersion: uag_sdk_1.ENGINE_API_VERSION,
-    description: 'Extracts nothing. For tests and local development.',
-    create: ({ name }) => (0, formflow_1.stubAgentEngine)({ name }),
+    description: 'Extracts nothing; generates a predictable answer from the text it is given. For tests and local development.',
+    // Text only; its generate answer shows what reached it. Observing its requests keeps it a built-in stub.
+    create: ({ name }) => (0, formflow_1.stubAgentEngine)({ name, onGenerate: (request) => {
+            exports.stubGenerateRequests.push({ ...request, engine: name });
+            if (exports.stubGenerateRequests.length > exports.STUB_GENERATE_REQUESTS_KEPT)
+                exports.stubGenerateRequests.splice(0, exports.stubGenerateRequests.length - exports.STUB_GENERATE_REQUESTS_KEPT);
+        } }),
 });

package/lib/agent/tools.d.ts

@@ -1,10 +1,31 @@
 import { FormflowTool } from "../formflow";
+import type { AuthRequest } from "@formio/appserver";
 import type { UAGProjectInterface } from "../UAGProjectInterface";
-import { ToolInfo } from "../tools/utils";
-/** Every tool the UAG serves, including custom tools from configuration. */
+import { ToolEntry, ToolInfo } from "../tools/utils";
+/** Record the module a tool came from: its `execute` gets the module's API as `extra.module`. */
+export declare function setToolModule(entry: object, api: any): void;
+/**
+ * A `config.tools` entry as a tool for the project: a bound tool's static
+ * fields, overlaid with what its `bind(project)` returns. A tool without
+ * `bind` (the 1.x shape) is used as it is.
+ */
+export declare function resolveTool(project: UAGProjectInterface, entry: ToolEntry): Promise<ToolInfo | undefined>;
+/**
+ * Every tool the UAG serves, including custom tools from configuration, each
+ * entry of which is a tool, optionally bound to the project.
+ */
 export declare function allTools(project: UAGProjectInterface): Promise<ToolInfo[]>;
+/**
+ * Run a tool with its arguments and the `ToolExtra` for the project: the same
+ * call on `/mcp` and for Agent API research. `context` is whatever else the
+ * caller has (on `/mcp`, the MCP SDK's request context, with `authInfo`).
+ */
+export declare function runTool(tool: ToolInfo, project: UAGProjectInterface, args: any, context: {
+    authInfo: AuthRequest;
+    [key: string]: any;
+}): any;
 /**
  * An MCP tool as an Agentic Formflow tool: its schema as JSON, its arguments
  * validated with its own schema, and read-only only when annotated so.
  */
-export declare function formflowTool(tool: ToolInfo): FormflowTool;
+export declare function formflowTool(tool: ToolInfo, project: UAGProjectInterface): FormflowTool;

package/lib/agent/tools.js

@@ -3,19 +3,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setToolModule = setToolModule;
+exports.resolveTool = resolveTool;
 exports.allTools = allTools;
+exports.runTool = runTool;
 exports.formflowTool = formflowTool;
 const zod_1 = __importDefault(require("zod"));
 const tools_1 = require("../tools");
-/** Every tool the UAG serves, including custom tools from configuration. */
+const utils_1 = require("../tools/utils");
+/** The module API of the module each `config.tools` entry came from, for its `extra.module`. */
+const toolModules = new WeakMap();
+/** Record the module a tool came from: its `execute` gets the module's API as `extra.module`. */
+function setToolModule(entry, api) {
+    if (entry && typeof entry === 'object')
+        toolModules.set(entry, api);
+}
+/**
+ * A `config.tools` entry as a tool for the project: a bound tool's static
+ * fields, overlaid with what its `bind(project)` returns. A tool without
+ * `bind` (the 1.x shape) is used as it is.
+ */
+async function resolveTool(project, entry) {
+    if (!entry || typeof entry.bind !== 'function')
+        return entry;
+    const { bind, ...fixed } = entry;
+    const tool = { ...fixed, ...((await bind(project)) || {}) };
+    if (toolModules.has(entry))
+        toolModules.set(tool, toolModules.get(entry));
+    return tool;
+}
+/**
+ * Every tool the UAG serves, including custom tools from configuration, each
+ * entry of which is a tool, optionally bound to the project.
+ */
 async function allTools(project) {
-    return [...await (0, tools_1.getTools)(project), ...(project.config?.tools || [])].filter((tool) => !!tool?.name);
+    (0, utils_1.assertToolEntries)(project.config?.tools);
+    const custom = await Promise.all((project.config?.tools || []).map((entry) => resolveTool(project, entry)));
+    return [...await (0, tools_1.getTools)(project), ...custom].filter((tool) => !!tool?.name);
+}
+/**
+ * Run a tool with its arguments and the `ToolExtra` for the project: the same
+ * call on `/mcp` and for Agent API research. `context` is whatever else the
+ * caller has (on `/mcp`, the MCP SDK's request context, with `authInfo`).
+ */
+function runTool(tool, project, args, context) {
+    if (!tool.execute) {
+        return { content: [{ type: 'text', text: `The tool "${tool.name}" has no implementation.` }], isError: true };
+    }
+    const module = toolModules.get(tool);
+    const extra = { ...context, authInfo: context.authInfo, project, ...(module && { module }) };
+    return tool.execute(args ?? {}, extra);
 }
 /**
  * An MCP tool as an Agentic Formflow tool: its schema as JSON, its arguments
  * validated with its own schema, and read-only only when annotated so.
  */
-function formflowTool(tool) {
+function formflowTool(tool, project) {
     const schema = zod_1.default.object(tool.inputSchema || {});
     const inputSchema = zod_1.default.toJSONSchema(schema, { io: 'input', unrepresentable: 'any' });
     delete inputSchema.$schema;
@@ -28,6 +71,6 @@ function formflowTool(tool) {
             const parsed = schema.safeParse(args || {});
             return parsed.success ? { ok: true, value: parsed.data } : { ok: false, error: parsed.error.message };
         },
-        execute: async (args, auth) => tool.execute(args, { authInfo: auth })
+        execute: async (args, auth) => runTool(tool, project, args, { authInfo: auth })
     };
 }

package/lib/config.d.ts

@@ -1,7 +1,7 @@
 import { ServerConfig } from '@formio/appserver';
 import type { FormflowAgentApiConfig, FormflowRateLimit, FormflowRoutingConfig } from './formflow';
 import type { EngineInstanceSpec, EngineTypeDefinition } from '@formio/uag-sdk';
-import { ToolInfo } from './tools/utils';
+import type { ToolEntry, ToolInfo } from './tools/utils';
 import type { UAGDatabaseOptions } from './database';
 export type UAGForm = {
     name: string;
@@ -47,10 +47,32 @@ export type UAGToolOverride = {
     submission_update?: ToolInfo;
     find_submissions?: ToolInfo;
     agent_provide?: ToolInfo;
-    /** @deprecated The earlier name of `agent_provide`; also applied to it when `agent_provide` is not set. */
-    agent_provide_data?: ToolInfo;
     agent_decide?: ToolInfo;
     fetch_external_data?: ToolInfo;
+    read_document?: ToolInfo;
+};
+/** `config.documents`: limits and choices of the AI Document module (@formio/uag-extras/modules/ai-document). */
+export type UAGDocumentsConfig = {
+    /** Largest uploaded file read, in bytes (25 MB). DOCUMENTS_MAX_FILE_BYTES. */
+    maxFileBytes?: number;
+    /** Most files one component sends (10). */
+    maxFiles?: number;
+    /** Most bytes of one request's files (32 MB, the provider request cap). */
+    maxTotalBytes?: number;
+    /** Most pages once converted (500). DOCUMENTS_MAX_PAGES. */
+    maxPages?: number;
+    /** Most characters of text once converted (2,000,000). */
+    maxTextChars?: number;
+    /** One processing request, in ms (600000). DOCUMENTS_TIMEOUT_MS. */
+    timeoutMs?: number;
+    /** Comment line interval on a streamed response, in ms (15000). */
+    heartbeatMs?: number;
+    /** Concurrent processing requests per identity (3). */
+    perUser?: number;
+    /** The engine instance documents use. Default: the first capable agent engine. DOCUMENTS_ENGINE. */
+    engine?: string;
+    /** Converter name by MIME type, when several can do a step. */
+    prefer?: Record<string, string>;
 };
 /**
  * One engine instance: `"<type>"` or `"<name>:<type>"`, or `{ name, type, options }`, where the
@@ -87,6 +109,8 @@ export interface UAGChatConfig {
 export type UAGAgentApiConfig = FormflowAgentApiConfig & {
     anonymous?: UAGAnonymousConfig;
     chat?: UAGChatConfig;
+    /** The largest request body an agent operation takes, in bytes (AGENT_BODY_LIMIT). Default 5 MB. */
+    bodyLimit?: number;
 };
 /**
  * Express's `trust proxy` from TRUST_PROXY: `true` or `false`, a number of
@@ -100,8 +124,11 @@ export interface UAGConfig extends ServerConfig {
     baseUrl?: string;
     loginForm?: string;
     responseTemplates?: UAGTemplateConfig;
+    /** Limits and choices of the AI Document module. */
+    documents?: UAGDocumentsConfig;
     toolOverrides?: UAGToolOverride;
-    tools?: ToolInfo[];
+    /** Custom MCP tools: each a tool, optionally bound to the project with `bind(project)` (see ToolInfo.bind). */
+    tools?: ToolEntry[];
     /**
      * The engine instances to enable, as in `UAG_ENGINES` (`"jev"`, `"fast:claude"`) or as
      * `{ name, type, options }`. When unset, `UAG_ENGINES` is used; when neither names any, no

package/lib/database.d.ts

@@ -1,9 +1,9 @@
 import { Collection, Db, MongoClient, MongoClientOptions } from 'mongodb';
-import type { AuthCodeStore } from '@formio/appserver-core';
+import type { AuthCodeStore } from '@formio/appserver';
 /**
  * The UAG's own database (MONGO, with the database named by UAG_DATABASE). It
- * holds only the UAG's state: authorization codes for remote MCP clients, the
- * start of a license server outage, and task-run records. Never submissions.
+ * holds only the UAG's state: authorization codes for remote MCP clients, and
+ * task-run records. Never submissions.
  *
  * Every collection the UAG uses is named `uag-*`, and nothing else in the
  * database is read or written, so the database may be shared. Before writing
@@ -66,10 +66,5 @@ export declare class UAGDatabase {
     private privileged;
     /** Authorization codes for remote MCP clients (MCP_OAUTH), in `uag-authcodes`. */
     authCodeStore(): AuthCodeStore;
-    /** When the license server became unreachable, in `uag-meta`, so a restart neither begins nor extends the grace period. */
-    licenseGrace(): {
-        read(): Promise<number | undefined>;
-        write(since?: number): Promise<void>;
-    };
     close(): Promise<void>;
 }

package/lib/database.js

@@ -6,8 +6,8 @@ const mongodb_1 = require("mongodb");
 const debug = require('debug')('formio:uag:database');
 /**
  * The UAG's own database (MONGO, with the database named by UAG_DATABASE). It
- * holds only the UAG's state: authorization codes for remote MCP clients, the
- * start of a license server outage, and task-run records. Never submissions.
+ * holds only the UAG's state: authorization codes for remote MCP clients, and
+ * task-run records. Never submissions.
  *
  * Every collection the UAG uses is named `uag-*`, and nothing else in the
  * database is read or written, so the database may be shared. Before writing
@@ -23,7 +23,6 @@ exports.UAG_COLLECTIONS = Object.freeze({
 const PREFIX = 'uag-';
 const APP = 'formio-uag';
 const SCHEMA_ID = 'schema';
-const LICENSE_ID = 'license';
 const RETENTION_INDEX = 'retention';
 const DEFAULT_RETENTION_DAYS = 90;
 // MongoDB's "Unauthorized" error.
@@ -206,22 +205,6 @@ class UAGDatabase {
             }
         };
     }
-    /** When the license server became unreachable, in `uag-meta`, so a restart neither begins nor extends the grace period. */
-    licenseGrace() {
-        const meta = this.meta;
-        const database = this;
-        return {
-            async read() {
-                const found = await meta.findOne({ _id: LICENSE_ID });
-                return typeof found?.outageSince === 'number' ? found.outageSince : undefined;
-            },
-            async write(since) {
-                // It may write before the license is known, so it never leaves uag-* collections without the marker.
-                await database.bootstrap();
-                await meta.updateOne({ _id: LICENSE_ID }, since === undefined ? { $unset: { outageSince: '' } } : { $set: { outageSince: since } }, { upsert: true });
-            }
-        };
-    }
     async close() {
         await this.client.close();
     }

package/lib/documents/convert.d.ts

@@ -0,0 +1,38 @@
+import type { PluginContext } from '@formio/appserver';
+import type { Converter, ConverterOutput, Representation } from './types';
+export declare const CONVERTER_DEFAULTS: {
+    maxBytes: number;
+    timeoutMs: number;
+    concurrency: number;
+};
+/** A conversion that did not complete. The message names the converter and the file, never its content. */
+export declare class ConversionError extends Error {
+    constructor(message: string);
+}
+export type ConvertOptions = {
+    to: Representation;
+    settings?: Record<string, any>;
+    signal?: AbortSignal;
+    log: PluginContext['log'];
+};
+/**
+ * Run one conversion: under the converter's size limit, in a temporary
+ * directory made for the call and removed after it, aborted at its timeout,
+ * and queued behind its other conversions beyond its concurrency.
+ */
+export declare function runConverter(converter: Converter, input: {
+    buffer: Buffer;
+    type: string;
+    name: string;
+}, options: ConvertOptions): Promise<ConverterOutput>;
+/**
+ * Run a route: each step's output feeds the next (an intermediate step always
+ * makes a PDF), with each converter's operator settings.
+ */
+export declare function runRoute(steps: Converter[], input: {
+    buffer: Buffer;
+    type: string;
+    name: string;
+}, to: Representation, options: Omit<ConvertOptions, 'to' | 'settings'> & {
+    settingsOf?: (converter: Converter) => Record<string, any> | undefined;
+}): Promise<ConverterOutput>;

package/lib/documents/convert.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversionError = exports.CONVERTER_DEFAULTS = void 0;
+exports.runConverter = runConverter;
+exports.runRoute = runRoute;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.CONVERTER_DEFAULTS = { maxBytes: 25 * 1024 * 1024, timeoutMs: 120000, concurrency: 2 };
+/** A conversion that did not complete. The message names the converter and the file, never its content. */
+class ConversionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConversionError';
+    }
+}
+exports.ConversionError = ConversionError;
+/**
+ * A queue per converter, so at most `concurrency` of its conversions run at
+ * once. A slot is held until its conversion has actually stopped: a converter
+ * that ignores its signal still counts after its caller has given up on it.
+ */
+class Queue {
+    constructor(limit) {
+        this.limit = limit;
+        this.running = 0;
+        this.waiting = [];
+    }
+    /** Wait for a slot; the returned function frees it (once). */
+    async acquire(signal) {
+        signal?.throwIfAborted();
+        if (this.running < this.limit) {
+            this.running++;
+        }
+        else {
+            // A freed slot passes straight to the next waiter, so no new caller can take it in between.
+            await new Promise((resolve, reject) => {
+                const go = () => { signal?.removeEventListener('abort', cancel); resolve(); };
+                const cancel = () => { this.waiting = this.waiting.filter((entry) => entry !== go); reject(signal.reason ?? new Error('aborted')); };
+                this.waiting.push(go);
+                signal?.addEventListener('abort', cancel, { once: true });
+            });
+        }
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = this.waiting.shift();
+            if (next)
+                next();
+            else
+                this.running--;
+        };
+    }
+}
+const queues = new WeakMap();
+/**
+ * Run one conversion: under the converter's size limit, in a temporary
+ * directory made for the call and removed after it, aborted at its timeout,
+ * and queued behind its other conversions beyond its concurrency.
+ */
+async function runConverter(converter, input, options) {
+    const limits = { ...exports.CONVERTER_DEFAULTS, ...(converter.limits || {}) };
+    if (input.buffer.length > limits.maxBytes) {
+        throw new ConversionError(`"${input.name}" is larger than the ${converter.name} converter takes (${limits.maxBytes} bytes).`);
+    }
+    let queue = queues.get(converter);
+    if (!queue) {
+        queue = new Queue(Math.max(1, limits.concurrency));
+        queues.set(converter, queue);
+    }
+    const release = await queue.acquire(options.signal);
+    let tmpdir;
+    try {
+        options.signal?.throwIfAborted();
+        tmpdir = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'uag-convert-'));
+    }
+    catch (err) {
+        release();
+        throw err;
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.signal?.aborted)
+        abort();
+    const work = Promise.resolve().then(() => converter.convert(input, { to: options.to, settings: options.settings || {}, signal: controller.signal, tmpdir, log: options.log }));
+    // The slot and the temporary directory are kept until convert() settles, even after a timeout or an abort.
+    const stopped = work.then(() => undefined, () => undefined).then(async () => {
+        await fs_1.default.promises.rm(tmpdir, { recursive: true, force: true }).catch(() => undefined);
+        release();
+    });
+    let timer;
+    let finished = false;
+    try {
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                const error = new ConversionError(`Converting "${input.name}" with ${converter.name} took longer than ${limits.timeoutMs} ms.`);
+                // Abort first: a converter running a process stops it on its signal.
+                controller.abort(error);
+                reject(error);
+            }, limits.timeoutMs);
+        });
+        const aborted = new Promise((_, reject) => {
+            if (controller.signal.aborted)
+                reject(controller.signal.reason);
+            controller.signal.addEventListener('abort', () => reject(controller.signal.reason), { once: true });
+        });
+        const output = await Promise.race([work.finally(() => { finished = true; }), timeout, aborted]);
+        return checkOutput(converter, input.name, options.to, output);
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', abort);
+        // A conversion that completed has its directory removed before its result is used.
+        if (finished)
+            await stopped;
+    }
+}
+function checkOutput(converter, name, to, output) {
+    if (to === 'pdf') {
+        if (!output || !Buffer.isBuffer(output.pdf))
+            throw new ConversionError(`The ${converter.name} converter did not produce a PDF for "${name}".`);
+        return output;
+    }
+    if (!output || typeof output.text !== 'string' || !['plain', 'markdown', 'csv'].includes(output.textFormat)) {
+        throw new ConversionError(`The ${converter.name} converter did not produce text for "${name}".`);
+    }
+    return output;
+}
+/**
+ * Run a route: each step's output feeds the next (an intermediate step always
+ * makes a PDF), with each converter's operator settings.
+ */
+async function runRoute(steps, input, to, options) {
+    let current = input;
+    let output;
+    for (let i = 0; i < steps.length; i++) {
+        const target = i === steps.length - 1 ? to : 'pdf';
+        output = await runConverter(steps[i], current, { ...options, to: target, settings: options.settingsOf?.(steps[i]) });
+        if (target === 'pdf')
+            current = { buffer: output.pdf, type: 'application/pdf', name: input.name };
+    }
+    if (!output)
+        throw new ConversionError(`No converter step for "${input.name}".`);
+    return output;
+}