@formio/uag 1.9.0-rc.2 → 1.9.0-rc.4

package/README.md

@@ -84,7 +84,8 @@ The following tools provided by the UAG can be described as follows:
 | confirm_form_submission | This tool is used to provide a summary of all data collected before a submission is made to the form. |
 | submit_completed_form | Provides the AI agent with the ability to submit all of the data collected from the user to create the form submission. |
 | find_submissions | Enables the agent to parse a user's natural language request into a query for a submission, or a specific field of a particular submission. |
-| submission_update | Provides the AI agent with the ability to update an existing submission, either by supplying unfilled fields or updating existing ones if allowed. Provides the AI agent with the context of the existing field values, allowing inline changes or edits. | 
+| submission_update | Provides the AI agent with the ability to update an existing submission, either by supplying unfilled fields or updating existing ones if allowed. Provides the AI agent with the context of the existing field values, allowing inline changes or edits. |
+| agent_provide_data | Enables an AI Agent to be able to analyze existing submission data according to rules defined with a configurable **Criteria**. It will then instruct the Agent to provide generated data for fields configured for a specific **persona** using the `submission_update` tool. Please read the [**Agent Provided Data**](#agent-provide-data) section for more information about this toolset. |
 
 ### Custom Modules
 While the UAG can be used as a stand-alone system to enable the interaction between AI agents and dynamic JSON forms, the true power of this platform will be realized when developers extend the capabilities of this platform to solve industry specific use cases through the use of Custom Modules and Tools. It is possible for a developer to create a **Module** that introduces a number of custom tools, actions, and pre-defined resources and forms to achieve interactions with industry specific technologies.
@@ -429,6 +430,61 @@ try {
 
 There is also a way to extend the functionality of the UAG through the use of modules, which is documented in the [Modules Readme](./module/Readme.md)
 
+## Agentic Workflows
+One of the more powerful features of the **UAG** is the `agent_process_data` tool. This tool provides the ability to instruct a generically trained agent how to analyze existing submission data, and then produce its own data by following a configurable **Criteria**. This behavior historically could only be achieved using a specifically trained agent, which does not provide any benefits of dynamic configurability that the Form.io platform offers. This tool is able to achieve this goal by providing a generally trained agent with the necessary "context" it needs to accurately produce its own data as part of an automated workflow. This feature is particularly helpful if you wish to utilize the UAG within an Agentic Workflow, where the AI Agent is capable of understanding structured data, and then contribute its own data by following the configured **Criteria** "context" provided by the UAG. 
+
+For example, let's suppose you wish to automate the backend administration behind a College Application Process. In this example, a potential student submits an application that consists of many different fields of data, such as Academnics, Extra curricular activities, Honors, Volunteer work, as well as possibly written Essays. Historically, these applications would be reviewed by an administrator in order to assess the candidates qualifications for acceptance. With the `agent_provide_data` tool, it is now possible to automate this process as the following diagram illustrates.
+
+![](./examples/images/uag-agent-provide-data.png)
+
+To achieve this feat, the `agent_provide_data` tool utilizes the following information, which is then fed to the Generally trained agent to produce its own submission data.
+
+ - **Existing Submission Data**: In order for the agent to be able to contribute its own data, it must first have an existing submission to be used as the data that it will analyze according to the configured **Criteria**.
+ - **Criteria**: This is a piece of content that provides the agent the **Criteria** to follow when analyzing the data, but also provides instructions on how the agent should populate the **Required Fields**.
+ - **Required Fields**: These are the form fields which the Agent is required to fill out as part of the `agent_provide_data` process.
+
+### Setup
+ To configure a form to use the `agent_provide_data` tool, you must first designate a section of your form that will be read and used by the AI Agent. This is similar to what you would see in a form that says "For Office Use Only", but instead of a Human contributing to the values of this section, it will be an automated AI Agent. There are two types of fields that can be added to a form to configure it for use by the `agent_provide_data` tool:  **Criteria** and **Agent Fields**
+ 
+#### Agent "Criteria" component
+The first thing that needs to be configured is a special **Content Component** that instructs the AI Agent how to interpret the data. For example, here is a Criteria content block that was written to instruct an AI Agent on how to assess the submission of a College Application Essay.
+
+![](./examples/images/criteria-example.png)
+
+The goal of this content is to be written as you would write an instruction manual for a new employee who needs to learn how to analyze and understand the submission data that is provided. It is also used to instruct the AI Agent on how to populate the form values that are configured for that criteria.  Once this criteria is written, It will then need to be "flagged" as a UAG field by adding a property called `uag` and the value of that property is to be thought of as the `persona` of the Agent. This provides the ability to have more than one agent assume different roles as it analyzes the submission data to provide their own values. In addition, the "criteria" content will also need to be provided a `uagField` property with the value equal to `criteria`.  Below is what a properly configured `uag` criteria content component looks like.  
+
+![](./examples/images/criteria-properties.png)
+
+Once you have added this `Criteria` **Content Component** to your form, the next object is to add the fields you wish for the Agent to populate. These are called the **Agent Fields**. 
+
+#### Agent Fields
+Anywhere in your form, you can drag and drop fields that can be flagged as Agent fields. Using the example above, imagine your form has a "For Office Use Only" section (maybe a Panel).  Within this panel, the first thing you see is a Content Component with instructions on how the following fields should be filled out. This is the `Criteria` we just described. The next thing that follows are the fields that the Agent needs to populate. Any field that with a property of `uag` set to the same value as the `Criteria` content component will be used as the Agent fields. 
+
+For example, lets suppose that we have created a form for College Application essays. Below the **Criteria** may be some fields that the Agent needs to "score" the essays according to the provided **Criteria**.  This may look like the following...
+
+![](./examples/images/agent-fields.png)
+
+In order to "flag" each of these fields as Agent Fields, you simply need to add the `uag` property with the same persona flag that was giving to the `Criteria` content.
+
+![](./examples/images/agent-field-property.png)
+
+**Nested Components**
+It is also possible to "flag" a collection of fields with the `uag` property. This can be done by wrapping all of these fields within a **Nested Component** (such as Panel, Container, Fieldset, etc), and then all the fields within this nested component will be added to the context of that agent with that persona.
+
+### Multiple Persona's per form
+It is also possible to achieve multiple persona's per-form. This is very helpful if there are several isolated evaluations that need to occur within a process. For example, if we look at the flow chart diagram shown above, we can see a College Application Form. The first agentic evaluation occurs when the form is submitted by the applicant, where their application is assessed to be accepted or not. From that point, IF the applicant is accepted, a completely different evaluation needs to occur to award Financial Aid or even Scholarships to the applicant. These would require completely different criteria to assess the submission data differently from one another.
+
+To achieve this, you simply need to "flag" the components `uag` property value differently with the persona that applies for that field. For the example above, you would add a Content component to assess the if the applicant should be accepted, and then provide the following `uag` property to that content.  `uag="application"`.  Any fields that need to be filled out by the AI Agent for application approval would also be flagged with the property `uag="application"`.  Then, in a different section of the form, you would create a separate Content component with the criteria for the financial admin AI Agent. This content would be flagged with the property `uag="finance"`.  Any fields that the finance admin AI Agent need to fill out would also be flagged with `uag="finance"`.  This provides a truely flexible and dynamic AI engagement where multiple generically trained agents can be "taught" dynamically how to read and interpret data that is only relevant to that part of the agentic process.
+
+## Integrations
+In order to a aid in the "agentification" of the UAG, we have also provided some "integrations" that can be used to directly communicate with the Generically trained AI Agents to utilize the UAG to accomplish automated AI Agent behaviors. This involves providing a single API endpoint that is capable of triggering the AI Agent process along with the connections to your deployed UAG. These API endpoints can then be triggered using a simple Webhook action within a form to start an Agentic process as the result of a Form submission.
+
+These integrations can be found within the **integrations** folder. The following **integrations** are provided to enable automated Agentic workflows.
+
+  - [Claude Integration](./integrations/claude)
+
+Please click on one of these integration links to read how they work.
+
 ## Using with Form.io Enterprise Server
 When using the UAG with the Form.io Enterprise Server, you unlock several benefits with regards to managing the Forms and Resources within the UAG. Some of the features that you gain with our Enterprise Server include:
 

package/lib/UAGFormInterface.d.ts

@@ -1,4 +1,4 @@
-import { AuthRequest, FormInterface, InterpolatedError } from "@formio/appserver";
+import { AppServerForm, AuthRequest, FormInterface, InterpolatedError } from "@formio/appserver";
 import { Component, Submission, DataObject } from "@formio/core";
 import { UAGForm } from "./config";
 import { ParentInfo } from "./tools";
@@ -15,6 +15,7 @@ export type UAGComponentInfo = {
     }[];
     prompt?: string;
     nested?: boolean;
+    rule?: string;
 };
 export type UAGData = Array<{
     label: string;
@@ -48,8 +49,15 @@ export type FormFieldInfo = {
         components: UAGComponentInfo[];
     };
 };
+export type UAGFields = {
+    persona: string;
+    criteria: string;
+    components: Record<string, UAGComponentInfo>;
+};
 export declare class UAGFormInterface extends FormInterface {
     uag: UAGForm | null;
+    uagFields: Record<string, UAGFields>;
+    setComponent(form: AppServerForm, component: Component, path: string): void;
     getComponentFormat(component: Component): string;
     getComponentInfo(component: Component, path: string): UAGComponentInfo;
     isMultiple(component: Component | undefined): boolean;
@@ -121,4 +129,5 @@ export declare class UAGFormInterface extends FormInterface {
     convertToSubmission(data?: Record<string, any>): Submission;
     formatData(data?: DataObject): UAGData;
     formatSubmission(submission: Submission): UAGSubmission;
+    htmlToMarkdown(html: string): string;
 }

package/lib/UAGFormInterface.js

@@ -4,10 +4,46 @@ exports.UAGFormInterface = void 0;
 const appserver_1 = require("@formio/appserver");
 const core_1 = require("@formio/core");
 const lodash_1 = require("lodash");
+const node_html_markdown_1 = require("node-html-markdown");
 class UAGFormInterface extends appserver_1.FormInterface {
     constructor() {
         super(...arguments);
         this.uag = null;
+        this.uagFields = {};
+    }
+    setComponent(form, component, path) {
+        if (form.tags?.includes('uag') && component.properties?.uag) {
+            const persona = component.properties?.uag;
+            if (!this.uagFields) {
+                this.uagFields = {};
+            }
+            let uagFields = this.uagFields[persona];
+            if (!uagFields) {
+                uagFields = { components: {} };
+            }
+            if (component.properties?.uagField) {
+                const property = component.properties?.uagField;
+                if (component?.html) {
+                    uagFields[property] = this.htmlToMarkdown(component.html);
+                }
+            }
+            else {
+                if (component.components) {
+                    core_1.Utils.eachComponent(component.components, (subComp, subPath) => {
+                        const compInfo = this.getComponentInfo(subComp, `${path}.${subPath}`);
+                        compInfo.rule = this.getComponentValueRule(subComp);
+                        uagFields.components[compInfo.path] = compInfo;
+                    });
+                }
+                else {
+                    const compInfo = this.getComponentInfo(component, path);
+                    compInfo.rule = this.getComponentValueRule(component);
+                    uagFields.components[compInfo.path] = compInfo;
+                }
+            }
+            this.uagFields[persona] = uagFields;
+        }
+        return super.setComponent(form, component, path);
     }
     getComponentFormat(component) {
         switch (component.type) {
@@ -401,8 +437,13 @@ class UAGFormInterface extends appserver_1.FormInterface {
     formatData(data = {}) {
         const uagData = [];
         let prefix = '';
+        let withinUAG = false;
         core_1.Utils.eachComponentData(this.form?.components || [], data, (component, data, row, path) => {
             let value = (0, lodash_1.get)(data, path);
+            if (component.key === 'uag' || withinUAG) {
+                withinUAG = true;
+                return true;
+            }
             if (this.isNestedComponent(component)) {
                 uagData.push({
                     prefix,
@@ -413,6 +454,11 @@ class UAGFormInterface extends appserver_1.FormInterface {
                 prefix += '  ';
             }
             else if (this.inputComponent(component) && (0, core_1.componentHasValue)(component, value)) {
+                if (typeof value === 'string' &&
+                    ((component.editor === 'ckeditor') ||
+                        (component.editor === 'quill'))) {
+                    value = this.htmlToMarkdown(value);
+                }
                 uagData.push({
                     prefix,
                     path,
@@ -424,6 +470,9 @@ class UAGFormInterface extends appserver_1.FormInterface {
             if (this.isNestedComponent(component)) {
                 prefix = prefix.slice(0, -3);
             }
+            if (component.key === 'uag' || withinUAG) {
+                withinUAG = false;
+            }
         });
         return uagData;
     }
@@ -435,5 +484,13 @@ class UAGFormInterface extends appserver_1.FormInterface {
             modified: submission.modified
         };
     }
+    htmlToMarkdown(html) {
+        return node_html_markdown_1.NodeHtmlMarkdown.translate(html, {
+            bulletMarker: '-',
+            emDelimiter: '*',
+            strongDelimiter: '**',
+            indent: '  '
+        });
+    }
 }
 exports.UAGFormInterface = UAGFormInterface;

package/lib/UAGProjectInterface.js

@@ -56,7 +56,6 @@ class UAGProjectInterface extends appserver_1.ProjectInterface {
     async router() {
         const router = await super.router();
         const uagRouter = (0, router_1.UAGRouter)(this);
-        router.use('/uag', (req, res, next) => this.authorizeRequest(req, res, next), uagRouter);
         router.use('/mcp', (req, res, next) => this.authorizeRequest(req, res, next), uagRouter);
         return router;
     }

package/lib/config.d.ts

@@ -43,6 +43,7 @@ export type UAGToolOverride = {
     submit_completed_form?: ToolInfo;
     submission_update?: ToolInfo;
     find_submissions?: ToolInfo;
+    agent_provide_data?: ToolInfo;
 };
 export interface UAGConfig extends ServerConfig {
     baseUrl?: string;

package/lib/template.d.ts

@@ -31,8 +31,11 @@ export declare enum ResponseTemplate {
     fieldValidationErrors = "fieldValidationErrors",
     fields = "fields",
     fieldList = "fieldList",
+    fieldValues = "fieldValues",
     getAvailableForms = "getAvailableForms",
-    noFormsAvailable = "noFormsAvailable"
+    noFormsAvailable = "noFormsAvailable",
+    uagComponentNotFound = "uagComponentNotFound",
+    agentProcessData = "agentProcessData"
 }
 export declare class UAGTemplate {
     config: UAGTemplateConfig;

package/lib/template.js

@@ -69,8 +69,11 @@ var ResponseTemplate;
     ResponseTemplate["fieldValidationErrors"] = "fieldValidationErrors";
     ResponseTemplate["fields"] = "fields";
     ResponseTemplate["fieldList"] = "fieldList";
+    ResponseTemplate["fieldValues"] = "fieldValues";
     ResponseTemplate["getAvailableForms"] = "getAvailableForms";
     ResponseTemplate["noFormsAvailable"] = "noFormsAvailable";
+    ResponseTemplate["uagComponentNotFound"] = "uagComponentNotFound";
+    ResponseTemplate["agentProcessData"] = "agentProcessData";
 })(ResponseTemplate || (exports.ResponseTemplate = ResponseTemplate = {}));
 class UAGTemplate {
     constructor(config = {}) {

package/lib/templates/agentProcessData.md

@@ -0,0 +1,19 @@
+Please read and understand the following **--- CRITERIA ---** section. This section provides instructions on how to analyze the **--- SUBMISSION ---** section that follows. Your objective is to provide values defined within the **--- REQUIRED FIELDS ---** section, and then to submit those values using the `agent_submit_data` tool.
+
+--- CRITERIA ---
+<%= criteria %>
+--- END OF CRITERIA ---
+
+Please analyze the following submission data according to the rules defined in the **--- CRITERIA ---** section.
+
+--- SUBMISSION ---
+<%= values %>
+--- END OF SUBMISSION ---
+
+Now, provide values for the following **--- REQUIRED FIELDS ---** by analyzing the **--- SUBMISSION ---** data according to the rules specified within the **--- CRITERIA ---** section. 
+
+--- REQUIRED FIELDS ---
+<%= fields %>
+--- END OF REQUIRED FIELDS ---
+
+Once you have created values for the **--- REQUIRED FIELDS ---**, use the `submission_update` tool to update the submission with these values.

package/lib/templates/fieldList.md

@@ -2,4 +2,5 @@
 - **<%= field.label %>**
   - data_path: "<%= field.path %>"
   - field_type: <%= field.type %><% if (field.description) { %>
-  - Description: <%= field.description %><% } %><% }); %>
+  - Description: <%= field.description %><% } %><% if (field.rule) { %>
+  - Value Rule: "<%= field.rule %>"<% } %><% }); %>

package/lib/templates/fieldValues.md

@@ -0,0 +1,4 @@
+<% data.forEach(function(item) { %><%= item.prefix %>
+Question: **<%= item.label %>**:
+  - Answer: `<%= item.value %>`
+<% }); %>

package/lib/templates/submissionUpdated.md

@@ -3,7 +3,7 @@ Successfully updated the record in <%= form.title %>!
  - created: <%= created %>
  - modified: <%= modified %>
 
-**Updated Fields (<%= totalFieldsUpdated %> total):** (It is VERY important to show the values to the user exactly as they were submitted/posted)
+**Updated Fields (<%= totalFieldsUpdated %> total):**
 <% updateSummary.forEach(function(update) { %>
 - **<%= update.data_path %>:**
   - Previous: "<%= update.previous_value %>"

package/lib/templates/uagComponentNotFound.md

@@ -0,0 +1,11 @@
+<% if (error === 'no_uag') { %>
+There are no `uag` fields present within the provided form. In order to use the `agent_provide_data` tool, you must first flag certain fields as the **Criteria** and **Agent Fields**.
+ - **Criteria**: A content component with properties `uag="<%= persona %>"` and `uagField="criteria"`. Within the content of this component, provide detailed instructions (criteria) for the agent to follow when analyzing the data.
+ - **Agent Fields**: Any fields you wish the agent to populate with its own data, you must flag those fields with the property `uag="<%= persona %>"`. These fields will then be handed to the AI Agent as required fields for them to populate according to the provided **Criteria**.
+<% } %>
+<% if (error === 'no_criteria') { %>
+No `criteria` field was found within this form with the properties `uag="<%= persona %>"` and `uagField="criteria"`. To add `criteria`, add a Content component to the form and then give it the following properties: `uag="<%= persona %>"` and `uagField="criteria"`. Within the content of this component, provide detailed instructions (the criteria) for the agent to follow when analyzing the data.
+<% } %>
+<% if (error === 'no_fields') { %>
+There are no `uag` fields within this form under the provided `persona=<%= persona %>` that are available for the AI Agent to provide values for. To flag a field as fillable by the AI Agent, you must add the property and value `uag="<%= persona %>"`
+<% } %>

package/lib/tools/SchemaBuilder.d.ts

@@ -108,6 +108,11 @@ export declare class SchemaBuilder {
      * @returns
      */
     parent_path(): this;
+    /**
+     * The agent persona "type" to use when processing the existing submission data. The persona provides context to the agent on how to interpret and understand the data within the form submission. If not provided, the default persona defined within the form's UAG settings will be used.
+     * @returns
+     */
+    persona(): this;
     /**
      * An array of field updates to apply to the `form_data`.
      * Each update specifies the `data_path` and the complete new value.

package/lib/tools/SchemaBuilder.js

@@ -153,6 +153,14 @@ class SchemaBuilder {
         this.schema.parent_path = zod_1.default.string().optional().describe('The `data_path` of the parent component that contains nested components. Use this parameter if collecting data for fields within a specific nested component within a form. To find the `parent_path`, you can use the `get_field_info` tool, and use the `data_path` of any component that ****Has Nested Components**** = ✅ Yes. If not provided, the tool assumes data is being collected for the root form.');
         return this;
     }
+    /**
+     * The agent persona "type" to use when processing the existing submission data. The persona provides context to the agent on how to interpret and understand the data within the form submission. If not provided, the default persona defined within the form's UAG settings will be used.
+     * @returns
+     */
+    persona() {
+        this.schema.persona = zod_1.default.string().optional().describe('The agent persona "type" to use when processing the existing submission data. The persona provides context to the agent on how to interpret and understand the data within the form submission. If not provided, the default persona defined within the form\'s UAG settings will be used.');
+        return this;
+    }
     /**
      * An array of field updates to apply to the `form_data`.
      * Each update specifies the `data_path` and the complete new value.

package/lib/tools/agentProvideData.d.ts

@@ -0,0 +1,3 @@
+import { UAGProjectInterface } from "../UAGProjectInterface";
+import { ToolInfo } from "./utils";
+export declare const agentProvideData: (project: UAGProjectInterface) => Promise<ToolInfo>;

package/lib/tools/agentProvideData.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentProvideData = void 0;
+const template_1 = require("../template");
+const lodash_1 = require("lodash");
+const SchemaBuilder_1 = require("./SchemaBuilder");
+const agentProvideData = async (project) => {
+    return (0, lodash_1.defaultsDeep)(project.config?.toolOverrides?.agent_provide_data || {}, {
+        name: 'agent_provide_data',
+        title: 'Agent Provide Data',
+        description: 'Provides a mechanism for agents to process existing submission data, understand it, and then to provide additional data values provided a criteria and form context.',
+        inputSchema: (new SchemaBuilder_1.SchemaBuilder(project))
+            .form_name()
+            .submission_id()
+            .persona().schema,
+        execute: async ({ form_name, submission_id, persona }, extra) => {
+            const form = await project.getForm(form_name);
+            if (!form) {
+                return project.mcpResponse(template_1.ResponseTemplate.formNotFound, { formName: form_name }, true);
+            }
+            const uag = persona ? form.uagFields[persona] : Object.values(form.uagFields)[0];
+            if (!uag) {
+                return project.mcpResponse(template_1.ResponseTemplate.uagComponentNotFound, {
+                    persona: persona || 'default',
+                    error: 'no_uag'
+                }, true);
+            }
+            const submission = await form.loadSubmission(submission_id, extra.authInfo);
+            if (!submission) {
+                return project.mcpResponse(template_1.ResponseTemplate.submissionNotFound, {
+                    form: form.form,
+                    submissionId: submission_id
+                }, true);
+            }
+            if (!uag.criteria) {
+                return project.mcpResponse(template_1.ResponseTemplate.uagComponentNotFound, {
+                    persona: persona || 'default',
+                    error: 'no_criteria'
+                }, true);
+            }
+            const agentFields = Object.values(uag.components);
+            if (agentFields.length === 0) {
+                return project.mcpResponse(template_1.ResponseTemplate.uagComponentNotFound, {
+                    persona: persona || 'default',
+                    error: 'no_fields'
+                }, true);
+            }
+            // Collect more required fields.
+            return project.mcpResponse(template_1.ResponseTemplate.agentProcessData, {
+                persona: persona || 'default',
+                criteria: uag.criteria,
+                values: project.uagTemplate?.renderTemplate(template_1.ResponseTemplate.fieldValues, {
+                    data: form.formatData(submission.data)
+                }),
+                fields: project.uagTemplate?.renderTemplate(template_1.ResponseTemplate.fieldList, { fields: agentFields })
+            });
+        }
+    });
+};
+exports.agentProvideData = agentProvideData;

package/lib/tools/index.js

@@ -31,6 +31,7 @@ const findSubmission_1 = require("./findSubmission");
 Object.defineProperty(exports, "findSubmission", { enumerable: true, get: function () { return findSubmission_1.findSubmission; } });
 const submissionUpdate_1 = require("./submissionUpdate");
 Object.defineProperty(exports, "submissionUpdate", { enumerable: true, get: function () { return submissionUpdate_1.submissionUpdate; } });
+const agentProvideData_1 = require("./agentProvideData");
 __exportStar(require("./utils"), exports);
 const getTools = async (project) => {
     return [
@@ -41,7 +42,8 @@ const getTools = async (project) => {
         await (0, confirmSubmission_1.confirmSubmission)(project),
         await (0, submitForm_1.submitCompletedForm)(project),
         await (0, findSubmission_1.findSubmission)(project),
-        await (0, submissionUpdate_1.submissionUpdate)(project)
+        await (0, submissionUpdate_1.submissionUpdate)(project),
+        await (0, agentProvideData_1.agentProvideData)(project)
     ];
 };
 exports.getTools = getTools;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formio/uag",
-  "version": "1.9.0-rc.2",
+  "version": "1.9.0-rc.4",
   "description": "The Form.io Universal Agent Gateway (UAG).",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,7 +15,7 @@
     "build:ts": "npx tsc",
     "build:copy-templates": "mkdir -p lib/templates && cp src/templates/*.md lib/templates/",
     "build": "npm run clean && npm run build:ts && npm run build:copy-templates",
-    "build:docker": "npm run build && docker build -t formio/uag --platform=linux/amd64 .",
+    "build:docker": "npm run build && docker build -t formio/uag:rc --platform=linux/amd64 .",
     "test": "TS_NODE_PROJECT=tsconfig.test.json mocha --no-node-snapshot",
     "dev": "tsx --no-node-snapshot index.js",
     "start": "node --no-node-snapshot index.js"
@@ -23,17 +23,18 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@formio/appserver": "^2.9.0",
+    "@formio/appserver": "^2.11.0",
     "@formio/core": "2.5.1-dev.291.6557e4e",
-    "@modelcontextprotocol/sdk": "^1.25.2",
-    "cors": "^2.8.5",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "cors": "^2.8.6",
     "debug": "^4.4.1",
     "dotenv": "^17.2.1",
     "express": "^5.2.1",
     "jsonwebtoken": "^9.0.2",
-    "lodash": "^4.17.21",
+    "lodash": "^4.17.23",
     "node-cache": "^5.1.2",
-    "zod": "^4.3.5"
+    "node-html-markdown": "^2.0.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",
@@ -44,12 +45,12 @@
     "@types/jsonwebtoken": "^9.0.10",
     "@types/lodash": "^4.17.23",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^25.0.6",
+    "@types/node": "^25.1.0",
     "@types/supertest": "^6.0.3",
     "chai": "^6.2.2",
     "mocha": "^11.7.5",
     "supertest": "^7.2.2",
-    "terser": "^5.44.1",
+    "terser": "^5.46.0",
     "ts-node": "^10.9.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"