@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/domains/hooks/manifest.js

@@ -22,10 +22,9 @@ const manifest = {
     domain: DOMAIN,
     depKey: DEP_KEY,
     secondaryDepKeys: ['hookPresetHandlers'],
-    profiles: ['full'],
+    profiles: ['workflow', 'full'],
     ensure,
     registrations: [
-        { tool: t('ai_hook_generate'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookGenerate(a)) },
         { tool: t('ai_hook_inject'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookInject(a)) },
         { tool: t('ai_hook_get_data'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookGetData(a)) },
         { tool: t('ai_hook_list'), domain: DOMAIN, bind: b((h, a) => h.handleAIHookList(a)) },

package/dist/src/server/domains/instrumentation/definitions.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const instrumentationTools: Tool[];

package/dist/src/server/domains/instrumentation/definitions.js

@@ -0,0 +1,99 @@
+import { tool } from '../../registry/tool-builder.js';
+const queryTypes = [
+    'before-load-inject',
+    'runtime-hook',
+    'network-intercept',
+    'function-trace',
+];
+export const instrumentationTools = [
+    tool('instrumentation_session_create')
+        .desc('Create a new instrumentation session that groups hooks, intercepts, and traces into a single queryable container.\n\nAll subsequent instrumentation operations can be associated with this session for unified management and artifact export.')
+        .string('name', 'Optional human-readable name for the session')
+        .build(),
+    tool('instrumentation_session_list')
+        .desc('List all active instrumentation sessions with their operation and artifact counts.')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('instrumentation_session_destroy')
+        .desc('Destroy an instrumentation session, marking all its operations as completed. Session data is retained for querying but no new operations can be added.')
+        .string('sessionId', 'Session ID returned by instrumentation_session_create')
+        .required('sessionId')
+        .destructive()
+        .idempotent()
+        .build(),
+    tool('instrumentation_session_status')
+        .desc('Get detailed status for an instrumentation session including operation count, artifact count, and active/destroyed state.')
+        .string('sessionId', 'Session ID')
+        .required('sessionId')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('instrumentation_operation_register')
+        .desc('Register a new instrumentation operation within a session so hooks, intercepts, and traces become queryable evidence-producing work items.')
+        .string('sessionId', 'Session ID returned by instrumentation_session_create')
+        .enum('type', queryTypes, 'Instrumentation type to register')
+        .string('target', 'Function name, URL pattern, or script target for the operation')
+        .object('config', {}, 'Operation-specific configuration payload')
+        .required('sessionId', 'type', 'target')
+        .build(),
+    tool('instrumentation_operation_list')
+        .desc('List all operations (hooks, intercepts, traces) registered within a session, optionally filtered by type.')
+        .string('sessionId', 'Session ID')
+        .enum('type', queryTypes, 'Optional filter by instrumentation type')
+        .required('sessionId')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('instrumentation_artifact_record')
+        .desc('Record a captured artifact for an instrumentation operation so the session and evidence graph reflect observed runtime data.')
+        .string('operationId', 'Operation ID returned by instrumentation_operation_register')
+        .object('data', {}, 'Captured artifact payload such as args, returnValue, headers, or body')
+        .required('operationId', 'data')
+        .build(),
+    tool('instrumentation_artifact_query')
+        .desc('Query captured artifacts (args, return values, intercepted requests, trace data) from a session, optionally filtered by type and limited.')
+        .string('sessionId', 'Session ID')
+        .enum('type', queryTypes, 'Optional filter by artifact type')
+        .number('limit', 'Maximum number of artifacts to return', { default: 50 })
+        .required('sessionId')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('instrumentation_hook_preset')
+        .desc('Apply hooks domain preset hooks within an instrumentation session and persist the injected preset summary as session artifacts.')
+        .string('sessionId', 'Session ID returned by instrumentation_session_create')
+        .string('preset', 'Single preset id to inject')
+        .array('presets', { type: 'string' }, 'Multiple preset ids to inject in one call')
+        .boolean('captureStack', 'Whether injected presets should capture stack traces', {
+        default: false,
+    })
+        .boolean('logToConsole', 'Whether injected presets should log to console', { default: true })
+        .enum('method', ['evaluate', 'evaluateOnNewDocument'], 'Injection method forwarded to hook_preset', { default: 'evaluate' })
+        .prop('customTemplate', {
+        type: 'object',
+        additionalProperties: true,
+        description: 'Optional inline custom preset definition',
+    })
+        .prop('customTemplates', {
+        type: 'array',
+        items: { type: 'object', additionalProperties: true },
+        description: 'Optional inline custom preset definitions',
+    })
+        .required('sessionId')
+        .openWorld()
+        .build(),
+    tool('instrumentation_network_replay')
+        .desc('Replay a previously captured network request inside an instrumentation session and persist the replay result or dry-run preview as session artifacts.')
+        .string('sessionId', 'Session ID returned by instrumentation_session_create')
+        .string('requestId', 'Captured request ID returned by network_get_requests')
+        .object('headerPatch', { additionalProperties: { type: 'string' } }, 'Optional request header overrides')
+        .string('bodyPatch', 'Optional raw request body override')
+        .string('methodOverride', 'Optional HTTP method override')
+        .string('urlOverride', 'Optional destination URL override')
+        .number('timeoutMs', 'Optional replay timeout in milliseconds')
+        .boolean('dryRun', 'Preview the replay without sending the request', { default: true })
+        .required('sessionId', 'requestId')
+        .openWorld()
+        .build(),
+];

package/dist/src/server/domains/instrumentation/handlers.d.ts

@@ -0,0 +1,78 @@
+import type { InstrumentationSessionManager } from '../../instrumentation/InstrumentationSession.js';
+import type { ToolResponse } from '../../types.js';
+interface HookPresetHandlerLike {
+    handleHookPreset(args: Record<string, unknown>): Promise<ToolResponse>;
+}
+interface NetworkReplayHandlerLike {
+    handleNetworkReplayRequest(args: Record<string, unknown>): Promise<ToolResponse>;
+}
+interface InstrumentationHandlerDeps {
+    hookPresetHandlers?: HookPresetHandlerLike;
+    advancedHandlers?: NetworkReplayHandlerLike;
+}
+export declare class InstrumentationHandlers {
+    private readonly sessionManager;
+    private readonly deps;
+    constructor(sessionManager: InstrumentationSessionManager, deps?: InstrumentationHandlerDeps);
+    handleSessionCreate(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleSessionList(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleSessionDestroy(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleSessionStatus(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleOperationList(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleOperationRegister(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleArtifactQuery(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleArtifactRecord(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleHookPreset(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleNetworkReplay(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}
+export {};

package/dist/src/server/domains/instrumentation/handlers.js

@@ -0,0 +1,206 @@
+import { InstrumentationType } from '../../instrumentation/types.js';
+import { argString } from '../../domains/shared/parse-args.js';
+function jsonResponse(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+export class InstrumentationHandlers {
+    sessionManager;
+    deps;
+    constructor(sessionManager, deps = {}) {
+        this.sessionManager = sessionManager;
+        this.deps = deps;
+    }
+    async handleSessionCreate(args) {
+        try {
+            const name = argString(args, 'name');
+            const session = this.sessionManager.createSession(name || undefined);
+            return jsonResponse({ success: true, session });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleSessionList(_args) {
+        try {
+            const sessions = this.sessionManager.listSessions();
+            return jsonResponse({ success: true, totalSessions: sessions.length, sessions });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleSessionDestroy(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            this.sessionManager.destroySession(sessionId);
+            return jsonResponse({ success: true, sessionId, message: 'Session destroyed' });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleSessionStatus(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session)
+                return jsonResponse({ success: false, error: `Session "${sessionId}" not found` });
+            const stats = this.sessionManager.getSessionStats(sessionId);
+            return jsonResponse({ success: true, session, stats });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleOperationList(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            let ops = this.sessionManager.getSessionOperations(sessionId);
+            const typeFilter = argString(args, 'type');
+            if (typeFilter) {
+                ops = ops.filter((o) => o.type === typeFilter);
+            }
+            return jsonResponse({ success: true, totalOperations: ops.length, operations: ops });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleOperationRegister(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            const type = argString(args, 'type', '');
+            const target = argString(args, 'target', '');
+            const config = args.config && typeof args.config === 'object' && !Array.isArray(args.config)
+                ? args.config
+                : {};
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            if (!type)
+                return jsonResponse({ success: false, error: 'type is required' });
+            if (!target)
+                return jsonResponse({ success: false, error: 'target is required' });
+            const operation = this.sessionManager.registerOperation(sessionId, type, target, config);
+            return jsonResponse({ success: true, operation });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleArtifactQuery(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            const typeRaw = argString(args, 'type');
+            const type = typeRaw ? typeRaw : undefined;
+            const limit = typeof args.limit === 'number' ? args.limit : 50;
+            let artifacts = this.sessionManager.getArtifacts(sessionId, type);
+            if (limit > 0)
+                artifacts = artifacts.slice(0, limit);
+            return jsonResponse({ success: true, totalArtifacts: artifacts.length, artifacts });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleArtifactRecord(args) {
+        try {
+            const operationId = argString(args, 'operationId', '');
+            const data = args.data && typeof args.data === 'object' && !Array.isArray(args.data)
+                ? args.data
+                : undefined;
+            if (!operationId)
+                return jsonResponse({ success: false, error: 'operationId is required' });
+            if (!data)
+                return jsonResponse({ success: false, error: 'data is required' });
+            const artifact = this.sessionManager.recordArtifact(operationId, data);
+            return jsonResponse({ success: true, artifact });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleHookPreset(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            if (!this.deps.hookPresetHandlers) {
+                return jsonResponse({ success: false, error: 'hookPresetHandlers is not available' });
+            }
+            const delegatedArgs = { ...args };
+            delete delegatedArgs['sessionId'];
+            const result = await this.sessionManager.applyHookPreset(sessionId, this.deps.hookPresetHandlers, delegatedArgs);
+            return jsonResponse({
+                success: result.payload.success !== false && result.operation.status === 'completed',
+                operation: result.operation,
+                artifacts: result.artifacts,
+                result: result.payload,
+            });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleNetworkReplay(args) {
+        try {
+            const sessionId = argString(args, 'sessionId', '');
+            if (!sessionId)
+                return jsonResponse({ success: false, error: 'sessionId is required' });
+            if (!this.deps.advancedHandlers) {
+                return jsonResponse({ success: false, error: 'advancedHandlers is not available' });
+            }
+            const delegatedArgs = { ...args };
+            delete delegatedArgs['sessionId'];
+            const result = await this.sessionManager.replayNetworkRequest(sessionId, this.deps.advancedHandlers, delegatedArgs);
+            return jsonResponse({
+                success: result.payload.success !== false && result.operation.status === 'completed',
+                operation: result.operation,
+                artifacts: result.artifacts,
+                result: result.payload,
+            });
+        }
+        catch (error) {
+            return jsonResponse({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}

package/dist/src/server/domains/instrumentation/index.d.ts

@@ -0,0 +1,2 @@
+export { InstrumentationHandlers } from './handlers.js';
+export { instrumentationTools } from './definitions.js';

package/dist/src/server/domains/instrumentation/index.js

@@ -0,0 +1,2 @@
+export { InstrumentationHandlers } from './handlers.js';
+export { instrumentationTools } from './definitions.js';

package/dist/src/server/domains/instrumentation/manifest.d.ts

@@ -0,0 +1,63 @@
+import type { MCPServerContext } from '../../domains/shared/registry.js';
+import { InstrumentationHandlers } from '../../domains/instrumentation/handlers.js';
+type H = InstrumentationHandlers;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "instrumentation";
+    depKey: "instrumentationHandlers";
+    profiles: ("workflow" | "full")[];
+    ensure: typeof ensure;
+    workflowRule: {
+        patterns: RegExp[];
+        priority: number;
+        tools: string[];
+        hint: string;
+    };
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "instrumentation";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
+export default manifest;

package/dist/src/server/domains/instrumentation/manifest.js

@@ -0,0 +1,114 @@
+import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
+import { instrumentationTools } from '../../domains/instrumentation/definitions.js';
+import { InstrumentationHandlers } from '../../domains/instrumentation/handlers.js';
+import { InstrumentationSessionManager } from '../../instrumentation/InstrumentationSession.js';
+import { EvidenceGraphBridge } from '../../instrumentation/EvidenceGraphBridge.js';
+import { ReverseEvidenceGraph } from '../../evidence/ReverseEvidenceGraph.js';
+const DOMAIN = 'instrumentation';
+const DEP_KEY = 'instrumentationHandlers';
+const t = toolLookup(instrumentationTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+function ensure(ctx) {
+    const hookPresetHandlers = ctx.handlerDeps.hookPresetHandlers;
+    const advancedHandlers = ctx.handlerDeps.advancedHandlers;
+    let graph = ctx.getDomainInstance('evidenceGraph');
+    if (!graph) {
+        graph = new ReverseEvidenceGraph();
+        ctx.setDomainInstance('evidenceGraph', graph);
+    }
+    let sessionManager = ctx.getDomainInstance('instrumentationSessionManager');
+    if (!sessionManager) {
+        sessionManager = new InstrumentationSessionManager();
+        ctx.setDomainInstance('instrumentationSessionManager', sessionManager);
+    }
+    let bridge = ctx.getDomainInstance('evidenceGraphBridge');
+    if (!bridge) {
+        bridge = new EvidenceGraphBridge(graph);
+        ctx.setDomainInstance('evidenceGraphBridge', bridge);
+    }
+    sessionManager.setEvidenceBridge(bridge);
+    if (!ctx.instrumentationHandlers) {
+        ctx.instrumentationHandlers = new InstrumentationHandlers(sessionManager, {
+            hookPresetHandlers: hookPresetHandlers,
+            advancedHandlers: advancedHandlers,
+        });
+    }
+    return ctx.instrumentationHandlers;
+}
+const manifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: DOMAIN,
+    depKey: DEP_KEY,
+    profiles: ['workflow', 'full'],
+    ensure,
+    workflowRule: {
+        patterns: [
+            /(hook|intercept|trace|instrument).*(session|unified|manage|all)/i,
+            /(session|统一|会话).*(hook|拦截|追踪|仪器化|instrument)/i,
+        ],
+        priority: 95,
+        tools: [
+            'instrumentation_session_create',
+            'instrumentation_operation_register',
+            'instrumentation_artifact_record',
+            'instrumentation_artifact_query',
+            'instrumentation_hook_preset',
+            'instrumentation_network_replay',
+        ],
+        hint: 'Instrumentation session: create session → attach hook presets / network replay → record artifacts → query artifacts → destroy when done',
+    },
+    registrations: [
+        {
+            tool: t('instrumentation_session_create'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleSessionCreate(a)),
+        },
+        {
+            tool: t('instrumentation_session_list'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleSessionList(a)),
+        },
+        {
+            tool: t('instrumentation_session_destroy'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleSessionDestroy(a)),
+        },
+        {
+            tool: t('instrumentation_session_status'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleSessionStatus(a)),
+        },
+        {
+            tool: t('instrumentation_operation_register'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleOperationRegister(a)),
+        },
+        {
+            tool: t('instrumentation_operation_list'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleOperationList(a)),
+        },
+        {
+            tool: t('instrumentation_artifact_record'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleArtifactRecord(a)),
+        },
+        {
+            tool: t('instrumentation_artifact_query'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleArtifactQuery(a)),
+        },
+        {
+            tool: t('instrumentation_hook_preset'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleHookPreset(a)),
+        },
+        {
+            tool: t('instrumentation_network_replay'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleNetworkReplay(a)),
+        },
+    ],
+};
+export default manifest;

package/dist/src/server/domains/macro/definitions.js

@@ -1,45 +1,18 @@
+import { tool } from '../../registry/tool-builder.js';
 export const macroTools = [
-    {
-        name: 'run_macro',
-        description: 'Execute a registered macro by ID. Macros chain multiple MCP tools in sequence with inline progress reporting and atomic bailout.\n\nBuilt-in macros:\n- `deobfuscate_ast_flow` — deobfuscate → advanced deobfuscation → extract function tree\n- `unpacker_flow` — detect packer → extract → deobfuscate → beautify\n\nUser-defined macros are loaded from JSON files in `macros/` directory.\n\nUse `list_macros` to see all available macros.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                macroId: {
-                    type: 'string',
-                    description: 'ID of the macro to execute (e.g., "deobfuscate_ast_flow")',
-                },
-                inputOverrides: {
-                    type: 'object',
-                    description: 'Optional per-step input overrides keyed by step ID (e.g., { "deobfuscate": { "code": "..." } })',
-                    additionalProperties: {
-                        type: 'object',
-                        additionalProperties: true,
-                    },
-                },
-            },
-            required: ['macroId'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'list_macros',
-        description: 'List all available macros (built-in + user-defined from macros/ directory).',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-            additionalProperties: false,
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
+    tool('run_macro')
+        .desc('Execute a registered macro by ID with inline progress and atomic bailout')
+        .string('macroId', 'Macro ID to execute')
+        .prop('inputOverrides', {
+        type: 'object',
+        description: 'Per-step input overrides keyed by step ID',
+        additionalProperties: { type: 'object', additionalProperties: true },
+    })
+        .required('macroId')
+        .build(),
+    tool('list_macros')
+        .desc('List all available macros (built-in + user-defined)')
+        .readOnly()
+        .idempotent()
+        .build(),
 ];