bruce-models 7.1.86 → 7.1.88

package/dist/bruce-models.umd.js

@@ -14824,6 +14824,23 @@
         }
     })(exports.ExportCsv || (exports.ExportCsv = {}));
 
+    (function (ExportNsx) {
+        /**
+         * Starts a whole-account NSX backup export job.
+         * The generated NSX file is stored in the account's configured backup file store.
+         */
+        function AccountBackup(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req: reqParams } = params !== null && params !== void 0 ? params : {};
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                return api.POST("export/nsx/accountBackup", {}, exports.Api.PrepReqParams(reqParams));
+            });
+        }
+        ExportNsx.AccountBackup = AccountBackup;
+    })(exports.ExportNsx || (exports.ExportNsx = {}));
+
     (function (ExportUsd) {
         function Export(params) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -16214,27 +16231,19 @@
         }
         Plugin.Upload = Upload;
         /**
-         * Returns a run function to call that'll load a plugin within your provided container element.
-         * The run function will return a dispose function to call to remove the plugin.
+         * Resolves a plugin record and returns its unwrapped source.
          * @param params
          * @returns
          */
-        function GetRunFunction(params) {
+        function LoadPluginSource(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { containerId, container, pluginParams, pluginId, plugin, api, req } = params;
+                let { api, pluginId, plugin, req } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi({
                         loadConfig: true
                     });
                 }
                 yield api.Loading;
-                if (!containerId && container) {
-                    containerId = container.id;
-                    if (!containerId) {
-                        containerId = exports.ObjectUtils.UId();
-                        container.id = containerId;
-                    }
-                }
                 if (!plugin && pluginId) {
                     plugin = (yield Plugin.Get({
                         pluginId,
@@ -16276,6 +16285,39 @@
                 const start = fileContent.indexOf("{");
                 const end = fileContent.lastIndexOf("}");
                 fileContent = fileContent.substring(start + 1, end);
+                return {
+                    api,
+                    pluginId,
+                    plugin,
+                    fileContent
+                };
+            });
+        }
+        /**
+         * Returns a run function to call that'll load a plugin within your provided container element.
+         * The run function will return a dispose function to call to remove the plugin.
+         * @param params
+         * @returns
+         */
+        function GetRunFunction(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { containerId, container, pluginParams, pluginId, plugin, api, req } = params;
+                if (!containerId && container) {
+                    containerId = container.id;
+                    if (!containerId) {
+                        containerId = exports.ObjectUtils.UId();
+                        container.id = containerId;
+                    }
+                }
+                const loaded = yield LoadPluginSource({
+                    api,
+                    pluginId,
+                    plugin,
+                    req
+                });
+                pluginId = loaded.pluginId;
+                plugin = loaded.plugin;
+                const fileContent = loaded.fileContent;
                 const paramsId = exports.ObjectUtils.UId();
                 window[paramsId] = pluginParams ? pluginParams : {};
                 window["PLUGIN_" + pluginId] = plugin;
@@ -16350,6 +16392,64 @@
             });
         }
         Plugin.GetRunFunction = GetRunFunction;
+        /**
+         * Returns an invoke function that calls an AI_TOOL plugin headlessly.
+         * @param params
+         * @returns
+         */
+        function GetInvokeFunction(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { api, pluginId, plugin, req } = params;
+                const loaded = yield LoadPluginSource({
+                    api,
+                    pluginId,
+                    plugin,
+                    req
+                });
+                return {
+                    invoke: (args, context) => {
+                        const callId = exports.ObjectUtils.UId();
+                        const argsId = "PLUGIN_ARGS_" + callId;
+                        const contextId = "PLUGIN_CONTEXT_" + callId;
+                        const resultId = "PLUGIN_RESULT_" + callId;
+                        window[argsId] = args ? args : {};
+                        window[contextId] = Object.assign({ config: loaded.plugin.Settings ? loaded.plugin.Settings.config : undefined, plugin: loaded.plugin }, (context ? context : {}));
+                        const script = `
+                    function invoke() {
+                        "use strict";
+                        var Invoke;
+
+                        ${loaded.fileContent}
+
+                        if (typeof Invoke !== "function") {
+                            throw new Error("Plugin " + ${JSON.stringify(loaded.pluginId)}
+                                + " does not declare an Invoke function.");
+                        }
+
+                        window["${resultId}"] = Invoke(window["${argsId}"], window["${contextId}"]);
+                    }
+                    invoke();
+                `;
+                        try {
+                            // 'eval2 = eval' stops the linter from complaining about using eval.
+                            const eval2 = eval;
+                            eval2(script);
+                            // Invoke may hand back a plain value or a promise; normalise both.
+                            return Promise.resolve(window[resultId]);
+                        }
+                        catch (e) {
+                            return Promise.reject(e);
+                        }
+                        finally {
+                            delete window[argsId];
+                            delete window[contextId];
+                            delete window[resultId];
+                        }
+                    }
+                };
+            });
+        }
+        Plugin.GetInvokeFunction = GetInvokeFunction;
         /**
          * Returns cache identifier for a plugin.
          * Example: {
@@ -16389,6 +16489,133 @@
         Plugin.GetIndexFileCacheKey = GetIndexFileCacheKey;
     })(exports.Plugin || (exports.Plugin = {}));
 
+    /**
+     * Validation for AI_TOOL plugins.
+     */
+    (function (PluginAiTool) {
+        /** Location value that exposes a plugin as an AI Tool. */
+        PluginAiTool.LOCATION = "AI_TOOL";
+        /** Prefix that turns a plugin ID into its tool name. */
+        const TOOL_NAME_PREFIX = "plugin_";
+        /** Provider limit on a tool name, prefix included. */
+        const MAX_TOOL_NAME_LENGTH = 64;
+        /** Longest plugin ID that still fits inside the tool name limit. */
+        PluginAiTool.MAX_PLUGIN_ID_LENGTH = MAX_TOOL_NAME_LENGTH - TOOL_NAME_PREFIX.length;
+        /**
+         * Schema keywords that silently drop a tool out of strict mode instead of
+         * failing. The tool still works, but stops being structurally guaranteed,
+         * and nothing downstream reports that it happened.
+         */
+        const STRICT_INCOMPATIBLE_KEYWORDS = ["$ref", "$defs", "allOf", "not"];
+        /**
+         * Side effects an AI Tool may declare.
+         *
+         */
+        const ALLOWED_SIDE_EFFECTS = ["none", "external"];
+        function isPlainObject(value) {
+            return !!value && typeof value === "object" && !Array.isArray(value);
+        }
+        /**
+         * Walks a schema for a keyword that would disable strict mode.
+         * @param node
+         * @param depth bounded so a pathological schema cannot hang the save
+         * @returns the offending keyword, or null
+         */
+        function findStrictModeViolation(node, depth = 0) {
+            if (!node || typeof node !== "object" || depth > 32) {
+                return null;
+            }
+            if (Array.isArray(node)) {
+                for (const child of node) {
+                    const nested = findStrictModeViolation(child, depth + 1);
+                    if (nested) {
+                        return nested;
+                    }
+                }
+                return null;
+            }
+            for (const key of Object.keys(node)) {
+                if (STRICT_INCOMPATIBLE_KEYWORDS.includes(key)) {
+                    return key;
+                }
+                const nested = findStrictModeViolation(node[key], depth + 1);
+                if (nested) {
+                    return nested;
+                }
+            }
+            return null;
+        }
+        /**
+         * Returns why an AI Tool plugin cannot be saved, or null when it is valid.
+         *
+         * Messages are written for the administrator authoring the plugin, and say
+         * what to change rather than what failed.
+         * @param plugin
+         * @returns
+         */
+        function Validate(plugin) {
+            var _a, _b, _c, _d;
+            if (!plugin || plugin.Location !== PluginAiTool.LOCATION) {
+                return null;
+            }
+            const id = ((_a = plugin.ID) !== null && _a !== void 0 ? _a : "").trim();
+            if (!id) {
+                return "An AI Tool needs an ID: it becomes the tool name the agent calls.";
+            }
+            if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+                return `The ID "${id}" contains characters that are not allowed in a tool name. `
+                    + "Use letters, numbers, hyphens and underscores only.";
+            }
+            if (TOOL_NAME_PREFIX.length + id.length > MAX_TOOL_NAME_LENGTH) {
+                return `The ID is ${id.length} characters, which makes the tool name too long. `
+                    + `The maximum is ${PluginAiTool.MAX_PLUGIN_ID_LENGTH} characters.`;
+            }
+            const tool = (_b = plugin.Settings) === null || _b === void 0 ? void 0 : _b.tool;
+            if (!isPlainObject(tool)) {
+                return "An AI Tool must declare Settings.tool with an inputSchema the agent can call it with.";
+            }
+            // The tool name is an opaque ID, so it carries no signal about what the
+            // tool does. The description is the only thing the agent can select on:
+            // without one it is registered but never chosen, and nothing reports that.
+            const description = typeof tool.description === "string" ? tool.description.trim() : "";
+            if (!description && !((_c = plugin.Name) !== null && _c !== void 0 ? _c : "").trim()) {
+                return "An AI Tool needs a description. Set Settings.tool.description, or fill in the plugin's "
+                    + "Name and Description — the agent has nothing else to choose the tool on.";
+            }
+            if (!isPlainObject(tool.inputSchema)) {
+                return "Settings.tool.inputSchema is missing or is not an object.";
+            }
+            if (tool.inputSchema.type && tool.inputSchema.type !== "object") {
+                return `Settings.tool.inputSchema.type is "${tool.inputSchema.type}"; it must be "object".`;
+            }
+            const strictViolation = findStrictModeViolation(tool.inputSchema);
+            if (strictViolation) {
+                return `Settings.tool.inputSchema uses "${strictViolation}", which silently turns off strict mode `
+                    + "for this tool. Inline the schema instead.";
+            }
+            if (tool.annotations !== undefined && !isPlainObject(tool.annotations)) {
+                return "Settings.tool.annotations must be an object.";
+            }
+            const annotations = (_d = tool.annotations) !== null && _d !== void 0 ? _d : {};
+            if (annotations.sideEffect !== undefined) {
+                const sideEffect = String(annotations.sideEffect).trim().toLowerCase();
+                if (!ALLOWED_SIDE_EFFECTS.includes(sideEffect)) {
+                    return `sideEffect "${annotations.sideEffect}" is not allowed. AI Tools are read-only in this `
+                        + "release: use \"none\", or \"external\" for a reviewed read-only external request.";
+                }
+            }
+            if (annotations.timeoutMs !== undefined) {
+                if (typeof annotations.timeoutMs !== "number"
+                    || !isFinite(annotations.timeoutMs)
+                    || annotations.timeoutMs <= 0) {
+                    return "timeoutMs must be a positive number of milliseconds.";
+                }
+            }
+            return null;
+        }
+        PluginAiTool.Validate = Validate;
+    })(exports.PluginAiTool || (exports.PluginAiTool = {}));
+
     (function (ProgramKey) {
         /**
          * Known program IDs that Nextspace applications will reference.
@@ -20381,7 +20608,7 @@
     })(exports.UrlUtils || (exports.UrlUtils = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.86";
+    const VERSION = "7.1.88";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;