@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/dist/components/mcp/tools/operations.js

@@ -0,0 +1,303 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ALLOW = void 0;
+exports._setOperationFunctionMapForTest = _setOperationFunctionMapForTest;
+exports._setChooseOperationForTest = _setChooseOperationForTest;
+exports._setProcessLocalTransactionForTest = _setProcessLocalTransactionForTest;
+exports.registerOperationsTools = registerOperationsTools;
+/**
+ * Operations-profile tool generation. Walks Harper's `OPERATION_FUNCTION_MAP`
+ * and registers one MCP tool per operation that survives the
+ * `mcp.operations.allow` / `deny` filter.
+ *
+ * The default v1 allow list is read-only and intentionally narrow:
+ * `describe_*`, `list_*`, `search_*`, plus an explicit set of safe
+ * getters (`get_job`, `get_status`, `get_analytics`, `get_metrics`),
+ * `system_information`, `read_log`, `read_audit_log`. A `get_*` glob
+ * was rejected because it would have matched `get_configuration`
+ * (TLS/S3/auth secrets), `get_components` + `get_component_file` +
+ * `get_custom_function*` (component source code, which can embed
+ * secrets), `get_backup`, and `get_deployment{,_payload}` — none of
+ * which should default into the MCP surface even though
+ * `verifyPerms` still gates the actual call. Operators who want any
+ * of those opt in via `mcp.operations.allow`. Destructive ops carry
+ * `destructiveHint: true` so well-behaved MCP clients can surface a
+ * confirmation prompt.
+ *
+ * Tool dispatch delegates to `chooseOperation` + `processLocalTransaction`
+ * — the same path Harper's REST `/operation` endpoint uses. That means
+ * `verifyPerms` runs unchanged, replication catchup runs unchanged, and
+ * server-side validation errors surface as `isError: true` results without
+ * the MCP layer needing to know what each operation expects.
+ */
+const env = __importStar(require("../../../utility/environment/environmentManager.js"));
+const hdbTerms_ts_1 = require("../../../utility/hdbTerms.js");
+const harper_logger_ts_1 = __importDefault(require("../../../utility/logging/harper_logger.js"));
+const toolRegistry_ts_1 = require("../toolRegistry.js");
+const operations_ts_1 = require("./schemas/operations.js");
+// Test seams. Avoids importing Harper's heavy server-helpers graph from unit
+// tests that only want to exercise the registration logic.
+let _opMapOverride;
+let _chooseOperationOverride;
+let _processLocalTransactionOverride;
+function _setOperationFunctionMapForTest(m) {
+    _opMapOverride = m;
+}
+function _setChooseOperationForTest(fn) {
+    _chooseOperationOverride = fn;
+}
+function _setProcessLocalTransactionForTest(fn) {
+    _processLocalTransactionOverride = fn;
+}
+function loadServerUtilities() {
+    try {
+        // Lazy require: Harper's server-helpers graph initializes eagerly
+        // (RocksDB lock acquisition, schema preload). Loading it from a unit
+        // test that hasn't booted Harper throws; treat that as "we're not in
+        // a Harper process" and let callers gracefully no-op.
+        return require('../../../server/serverHelpers/serverUtilities');
+    }
+    catch (err) {
+        harper_logger_ts_1.default.trace(`MCP operations tools: serverUtilities unavailable (${err.message})`);
+        return undefined;
+    }
+}
+function getOperationFunctionMap() {
+    if (_opMapOverride)
+        return _opMapOverride;
+    const utils = loadServerUtilities();
+    return utils?.OPERATION_FUNCTION_MAP;
+}
+function getChooseOperation() {
+    if (_chooseOperationOverride)
+        return _chooseOperationOverride;
+    return loadServerUtilities()?.chooseOperation;
+}
+function getProcessLocalTransaction() {
+    if (_processLocalTransactionOverride)
+        return _processLocalTransactionOverride;
+    return loadServerUtilities()?.processLocalTransaction;
+}
+/**
+ * Default v1 allow list — read-only operations only. Operators who want
+ * destructive ops on the MCP surface opt in via `mcp.operations.allow`.
+ */
+exports.DEFAULT_ALLOW = [
+    'describe_*',
+    'list_*',
+    'search_*',
+    // Explicit safe getters only — see file-header rationale. `get_*` would
+    // pull in `get_configuration`, `get_components`, `get_custom_function*`,
+    // `get_backup`, and `get_deployment*`, all of which can leak secrets or
+    // source code into the LLM context even with `verifyPerms` enforcing.
+    'get_job',
+    'get_status',
+    'get_analytics',
+    'get_metrics',
+    'system_information',
+    'read_log',
+    'read_audit_log',
+];
+/**
+ * Operations that carry `destructiveHint: true` when opted into the allow
+ * list. The hint lets MCP clients surface a confirmation prompt before
+ * calling. It is **not** an authorization check — Harper's `verifyPerms`
+ * still runs at the actual dispatch site.
+ */
+const DESTRUCTIVE_OPERATIONS = new Set([
+    'drop_schema',
+    'drop_database',
+    'drop_table',
+    'drop_attribute',
+    'delete',
+    'delete_files_before',
+    'delete_records_before',
+    'delete_audit_logs_before',
+    'delete_transaction_logs_before',
+    'drop_user',
+    'drop_role',
+    'restart',
+    'restart_service',
+    'set_configuration',
+    'remove_node',
+]);
+/**
+ * Read-only operations carry `readOnlyHint: true`. The category is wider
+ * than the default allow list (some custom-allowed ops are also read-only
+ * — `system_information`, for example). Any op matching one of these
+ * prefixes or names is treated as read-only.
+ */
+const READ_ONLY_PREFIXES = ['describe_', 'list_', 'search_', 'get_', 'read_'];
+const READ_ONLY_NAMES = new Set(['system_information', 'status']);
+function isReadOnly(operationName) {
+    if (READ_ONLY_NAMES.has(operationName))
+        return true;
+    return READ_ONLY_PREFIXES.some((p) => operationName.startsWith(p));
+}
+function isDestructive(operationName) {
+    return DESTRUCTIVE_OPERATIONS.has(operationName);
+}
+/**
+ * Translates a single glob pattern (only `*` is supported) into a regex.
+ * `describe_*` matches `describe_schema`, `describe_table`, etc.; literals
+ * like `system_information` match exactly. No escape hatch yet — operators
+ * should use literals when they need them; the glob language is delibarately
+ * minimal to keep behavior predictable in audit/security reviews.
+ */
+function globToRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+function matchesAny(operation, patterns) {
+    if (!patterns || patterns.length === 0)
+        return false;
+    for (const p of patterns) {
+        if (globToRegex(p).test(operation))
+            return true;
+    }
+    return false;
+}
+function isOperationAllowed(operation, config) {
+    const allowList = config.allow && config.allow.length > 0 ? config.allow : exports.DEFAULT_ALLOW;
+    if (!matchesAny(operation, allowList))
+        return false;
+    if (matchesAny(operation, config.deny))
+        return false;
+    return true;
+}
+function getOperationsConfig() {
+    const allow = env.get(hdbTerms_ts_1.CONFIG_PARAMS.MCP_OPERATIONS_ALLOW);
+    const deny = env.get(hdbTerms_ts_1.CONFIG_PARAMS.MCP_OPERATIONS_DENY);
+    return {
+        allow: Array.isArray(allow) ? allow : undefined,
+        deny: Array.isArray(deny) ? deny : undefined,
+    };
+}
+function buildDescription(operationName, hasCuratedSchema) {
+    const base = `Harper operation '${operationName}'.`;
+    const schemaNote = hasCuratedSchema
+        ? ' Arguments validated against the curated schema below.'
+        : ' Arguments forwarded as-is; the server validates and returns a structured error on rejection.';
+    return base + schemaNote;
+}
+/**
+ * Build the dispatch handler for one operation. Returns a function suitable
+ * for `ToolDef.handler` that delegates to Harper's normal operation pipeline.
+ *
+ * Errors from `chooseOperation` (permission denied) or from the operation
+ * itself surface as `isError: true` MCP results, not JSON-RPC errors —
+ * matches the MCP spec's `tools/call` convention so the LLM sees and can
+ * adapt to the failure.
+ */
+function makeOperationToolHandler(operationName) {
+    return async function operationToolHandler(args, context) {
+        const body = {
+            ...(args && typeof args === 'object' ? args : {}),
+            operation: operationName,
+            hdb_user: context.user,
+        };
+        try {
+            const chooseOperation = getChooseOperation();
+            const processLocalTransaction = getProcessLocalTransaction();
+            if (!chooseOperation || !processLocalTransaction) {
+                throw new Error('Harper operations runtime unavailable');
+            }
+            const operationFn = chooseOperation(body);
+            const data = await processLocalTransaction({ body }, operationFn);
+            const text = typeof data === 'string' ? data : JSON.stringify(data ?? null);
+            const result = {
+                content: [{ type: 'text', text }],
+            };
+            if (data !== null && typeof data === 'object') {
+                result.structuredContent = data;
+            }
+            return result;
+        }
+        catch (err) {
+            const e = err;
+            const message = e?.http_resp_msg ?? e?.message ?? `operation '${operationName}' failed`;
+            harper_logger_ts_1.default.trace(`MCP operations/${operationName} threw: ${err.stack ?? message}`);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ kind: 'harper_error', operation: operationName, message }),
+                    },
+                ],
+            };
+        }
+    };
+}
+/**
+ * Idempotent registration: walk the op map, register every operation that
+ * passes the allow/deny filter. Safe to invoke multiple times — `addTool`
+ * is `Map.set`-backed.
+ */
+function registerOperationsTools() {
+    const opMap = getOperationFunctionMap();
+    if (!opMap) {
+        harper_logger_ts_1.default.warn('MCP operations profile: OPERATION_FUNCTION_MAP not available; no tools registered');
+        return;
+    }
+    const config = getOperationsConfig();
+    let registered = 0;
+    for (const operationName of opMap.keys()) {
+        if (!isOperationAllowed(operationName, config))
+            continue;
+        const inputSchema = operations_ts_1.OPERATION_INPUT_SCHEMAS[operationName] ?? operations_ts_1.PERMISSIVE_SCHEMA;
+        const annotations = {};
+        if (isReadOnly(operationName))
+            annotations.readOnlyHint = true;
+        if (isDestructive(operationName))
+            annotations.destructiveHint = true;
+        (0, toolRegistry_ts_1.addTool)({
+            name: operationName,
+            description: buildDescription(operationName, operationName in operations_ts_1.OPERATION_INPUT_SCHEMAS),
+            inputSchema,
+            profile: 'operations',
+            ...(Object.keys(annotations).length > 0 ? { annotations } : {}),
+            visibleTo: (user) => (0, toolRegistry_ts_1.canRoleInvokeOperation)(user, operationName),
+            handler: makeOperationToolHandler(operationName),
+        });
+        registered++;
+    }
+    harper_logger_ts_1.default.info(`MCP operations profile: registered ${registered} tool(s)`);
+}
+//# sourceMappingURL=operations.js.map

package/dist/components/mcp/tools/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../../../components/mcp/tools/operations.ts"],"names":[],"mappings":"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"}

package/dist/components/mcp/tools/schemas/derive.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Derive MCP tool input schemas from a Harper Resource's `Table.attributes`.
+ *
+ * Harper attribute types map to JSON Schema's primitive types; nested
+ * `properties[]` and array `elements` map recursively. `attribute_permissions`
+ * (per role, per table) narrows the schema by removing attributes the user
+ * can't read (for `get_*`/`search_*`) or write (for `create_*`/`update_*`).
+ *
+ * Runtime enforcement still happens in `Table.allowUpdate` /
+ * `Table.allowCreate` — the schema narrowing here is a UX layer (so the LLM
+ * doesn't waste tokens on fields it can't write), NOT a security boundary.
+ */
+export interface HarperAttribute {
+    name: string;
+    type?: string;
+    nullable?: boolean;
+    isPrimaryKey?: boolean;
+    properties?: HarperAttribute[];
+    elements?: HarperAttribute;
+    computed?: unknown;
+    computedFromExpression?: string;
+    assignCreatedTime?: boolean;
+    assignUpdatedTime?: boolean;
+    expiresAt?: boolean;
+}
+export interface AttributePermissionEntry {
+    attribute_name: string;
+    read?: boolean;
+    insert?: boolean;
+    update?: boolean;
+}
+export declare function deriveGetSchema(attributes: HarperAttribute[], _permissions: AttributePermissionEntry[] | undefined): object;
+export declare function deriveSearchSchema(attributes: HarperAttribute[], permissions: AttributePermissionEntry[] | undefined): object;
+export declare function deriveCreateSchema(attributes: HarperAttribute[], permissions: AttributePermissionEntry[] | undefined): object;
+export declare function deriveUpdateSchema(attributes: HarperAttribute[], permissions: AttributePermissionEntry[] | undefined): object;
+export declare function deriveDeleteSchema(attributes: HarperAttribute[], _permissions: AttributePermissionEntry[] | undefined): object;

package/dist/components/mcp/tools/schemas/derive.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Derive MCP tool input schemas from a Harper Resource's `Table.attributes`.
+ *
+ * Harper attribute types map to JSON Schema's primitive types; nested
+ * `properties[]` and array `elements` map recursively. `attribute_permissions`
+ * (per role, per table) narrows the schema by removing attributes the user
+ * can't read (for `get_*`/`search_*`) or write (for `create_*`/`update_*`).
+ *
+ * Runtime enforcement still happens in `Table.allowUpdate` /
+ * `Table.allowCreate` — the schema narrowing here is a UX layer (so the LLM
+ * doesn't waste tokens on fields it can't write), NOT a security boundary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveGetSchema = deriveGetSchema;
+exports.deriveSearchSchema = deriveSearchSchema;
+exports.deriveCreateSchema = deriveCreateSchema;
+exports.deriveUpdateSchema = deriveUpdateSchema;
+exports.deriveDeleteSchema = deriveDeleteSchema;
+/**
+ * Maps a Harper attribute type to a JSON Schema `type` value (or list of
+ * types when nullable). Falls back to "string" for unknown types — better
+ * than blocking the field entirely; the runtime will validate.
+ */
+function harperTypeToJsonSchema(type) {
+    switch (type) {
+        case 'Int':
+        case 'Long':
+        case 'BigInt':
+            return { type: 'integer' };
+        case 'Float':
+            return { type: 'number' };
+        case 'Boolean':
+            return { type: 'boolean' };
+        case 'String':
+        case 'ID':
+            return { type: 'string' };
+        case 'Date':
+            // Harper Date may be ISO string or number; allow both for LLM flexibility.
+            return { type: ['string', 'number'], description: 'ISO 8601 timestamp or epoch milliseconds.' };
+        case 'Bytes':
+        case 'Blob':
+            return { type: 'string', contentEncoding: 'base64' };
+        case 'Any':
+        case undefined:
+            return {};
+        default:
+            return { type: 'string' };
+    }
+}
+function attributeToProperty(attr) {
+    let base;
+    if (attr.type === 'Object' && attr.properties) {
+        base = {
+            type: 'object',
+            properties: Object.fromEntries(attr.properties.map((p) => [p.name, attributeToProperty(p)])),
+        };
+    }
+    else if (attr.type === 'Array' && attr.elements) {
+        base = {
+            type: 'array',
+            items: attributeToProperty(attr.elements),
+        };
+    }
+    else {
+        base = harperTypeToJsonSchema(attr.type);
+    }
+    if (attr.nullable && 'type' in base) {
+        const t = base.type;
+        const types = Array.isArray(t) ? t : [t];
+        if (!types.includes('null')) {
+            base.type = [...types, 'null'];
+        }
+    }
+    return base;
+}
+/**
+ * `true` if the user has the requested mode (read/insert/update) on this
+ * attribute. When no per-attribute permissions exist, returns true (the
+ * table-level perm gates the call already).
+ */
+function attributeAllowed(attributeName, permissions, mode) {
+    if (!permissions || permissions.length === 0)
+        return true;
+    const match = permissions.find((p) => p.attribute_name === attributeName);
+    if (!match)
+        return false; // explicit list with no entry → denied
+    return match[mode] !== false;
+}
+/**
+ * Build a JSON Schema object covering some subset of the table's attributes.
+ * `mode` controls how attribute_permissions are interpreted; `include`
+ * optionally limits to a subset (e.g. primary-key-only for `delete_*`).
+ */
+function buildPropertiesObject(attributes, permissions, mode, include) {
+    const properties = {};
+    const required = [];
+    for (const attr of attributes) {
+        if (include && !include(attr))
+            continue;
+        if (!attributeAllowed(attr.name, permissions, mode))
+            continue;
+        // Skip auto-managed columns from write inputs — Harper assigns them.
+        if (mode !== 'read' && (attr.assignCreatedTime || attr.assignUpdatedTime || attr.expiresAt))
+            continue;
+        if (mode !== 'read' && (attr.computed !== undefined || attr.computedFromExpression !== undefined))
+            continue;
+        properties[attr.name] = attributeToProperty(attr);
+        if (mode === 'insert' && !attr.nullable && !attr.isPrimaryKey) {
+            required.push(attr.name);
+        }
+    }
+    return { properties, required };
+}
+function findPrimaryKey(attributes) {
+    return attributes.find((a) => a.isPrimaryKey);
+}
+function deriveGetSchema(attributes, _permissions) {
+    const pk = findPrimaryKey(attributes);
+    const pkSchema = pk ? attributeToProperty(pk) : { type: 'string' };
+    return {
+        type: 'object',
+        properties: {
+            id: { ...pkSchema, description: pk ? `Primary key (${pk.name}).` : 'Primary key.' },
+            get_attributes: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Attribute names to project; defaults to all readable attributes.',
+            },
+        },
+        required: ['id'],
+    };
+}
+function deriveSearchSchema(attributes, permissions) {
+    // `conditions` is freeform — Harper supports many comparators; we expose
+    // the common subset and rely on server-side validation for the rest.
+    const readableAttrs = attributes.filter((a) => attributeAllowed(a.name, permissions, 'read'));
+    const attrNames = readableAttrs.map((a) => a.name);
+    return {
+        type: 'object',
+        properties: {
+            conditions: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        attribute: {
+                            type: 'string',
+                            ...(attrNames.length > 0 ? { enum: attrNames } : {}),
+                            description: 'Attribute name to filter on.',
+                        },
+                        comparator: {
+                            type: 'string',
+                            enum: [
+                                'equals',
+                                'not_equals',
+                                'contains',
+                                'starts_with',
+                                'ends_with',
+                                'greater_than',
+                                'less_than',
+                                'greater_than_equal',
+                                'less_than_equal',
+                                'between',
+                            ],
+                            description: 'Comparison operator. Defaults to "equals" if omitted.',
+                        },
+                        value: { description: 'Comparison value (any JSON type).' },
+                    },
+                    required: ['attribute', 'value'],
+                },
+            },
+            operator: { type: 'string', enum: ['and', 'or'], description: 'How to combine conditions; defaults to "and".' },
+            get_attributes: { type: 'array', items: { type: 'string' } },
+            limit: { type: 'integer', minimum: 1, description: 'Max records to return on this page.' },
+            cursor: { type: 'string', description: 'Opaque pagination cursor returned by a previous call.' },
+        },
+    };
+}
+function deriveCreateSchema(attributes, permissions) {
+    const { properties, required } = buildPropertiesObject(attributes, permissions, 'insert');
+    const schema = {
+        type: 'object',
+        properties,
+    };
+    if (required.length > 0)
+        schema.required = required;
+    return schema;
+}
+function deriveUpdateSchema(attributes, permissions) {
+    const pk = findPrimaryKey(attributes);
+    const { properties } = buildPropertiesObject(attributes, permissions, 'update', (a) => !a.isPrimaryKey);
+    return {
+        type: 'object',
+        properties: {
+            id: pk
+                ? { ...attributeToProperty(pk), description: `Primary key (${pk.name}). Required.` }
+                : { type: 'string', description: 'Primary key. Required.' },
+            ...properties,
+        },
+        required: ['id'],
+    };
+}
+function deriveDeleteSchema(attributes, _permissions) {
+    const pk = findPrimaryKey(attributes);
+    return {
+        type: 'object',
+        properties: {
+            id: pk
+                ? { ...attributeToProperty(pk), description: `Primary key (${pk.name}).` }
+                : { type: 'string', description: 'Primary key.' },
+        },
+        required: ['id'],
+    };
+}
+//# sourceMappingURL=derive.js.map

package/dist/components/mcp/tools/schemas/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../../../../components/mcp/tools/schemas/derive.ts"],"names":[],"mappings":"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"}

package/dist/components/mcp/tools/schemas/operations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hand-curated JSON Schemas for the operations-profile MCP tools.
+ *
+ * Why hand-curated: Harper's server-side validators are Joi, which doesn't
+ * round-trip cleanly to JSON Schema. The MCP spec requires draft-07-ish
+ * JSON Schema for tool inputSchema. Authoring these directly keeps the
+ * schemas readable, easy to tweak per the LLM ergonomics we want, and
+ * decoupled from server-side validation evolution.
+ *
+ * Each schema follows MCP convention: `type: 'object'` at the top, with
+ * `properties` declared and a small `required` list when applicable.
+ * Optional fields are listed but not required, so an LLM can call the
+ * minimum-viable form.
+ *
+ * Coverage matches the v1 conservative `allow` default in the design
+ * (#465 → Operations MCP). When operators expand `mcp.operations.allow`
+ * beyond this list, ops without an entry here fall back to a permissive
+ * `{ type: 'object' }` schema and a runtime-validates-as-it-goes posture
+ * — better than silently dropping them from the tool surface.
+ */
+/** Permissive default for any opted-in operation that doesn't have a hand-curated schema yet. */
+export declare const PERMISSIVE_SCHEMA: object;
+/**
+ * Map of operation name → input schema. Lookup misses fall back to
+ * `PERMISSIVE_SCHEMA`. Keys mirror `OPERATIONS_ENUM` values.
+ */
+export declare const OPERATION_INPUT_SCHEMAS: Record<string, object>;