@cplace/mcp-server 1.9.1 → 1.10.5

package/dist/tools/wizards.js

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { debugLogWithTag } from "../logger.js";
-import { checkResponseSize } from "../utils.js";
+import { z } from 'zod';
+import { debugLogWithTag } from '../logger.js';
+import { checkResponseSize } from '../utils.js';
 function stripPagePrefix(uid) {
     return uid.startsWith('page/') ? uid.substring(5) : uid;
 }
@@ -63,13 +63,13 @@ async function resolveWizard(client, workspaceId, wizardName) {
     debugLogWithTag('WIZARD_RESOLVE', `Resolving wizard '${wizardName}' in workspace '${workspaceId}'`);
     const cplaceFilter = {
         filters: [
-            { type: "Type", types: [WIZARD_TYPE] },
-            { type: "Workspace", workspaceIds: [workspaceId] },
-            { type: "BuiltinAttributeValue", attribute: "name", operator: "equals", string: wizardName }
-        ]
+            { type: 'Type', types: [WIZARD_TYPE] },
+            { type: 'Workspace', workspaceIds: [workspaceId] },
+            { type: 'BuiltinAttributeValue', attribute: 'name', operator: 'equals', string: wizardName },
+        ],
     };
     const searchResult = await client.makeApiRequest('json/search', 'GET', {
-        filter: JSON.stringify(cplaceFilter)
+        filter: JSON.stringify(cplaceFilter),
     });
     const pages = searchResult?.results || [];
     if (pages.length === 0) {
@@ -86,13 +86,18 @@ async function resolveWizardWithSteps(client, workspaceId, wizardName) {
     debugLogWithTag('WIZARD_RESOLVE', `Resolving steps for wizard '${wizardName}' (${wizard.uid})`);
     const stepFilter = {
         filters: [
-            { type: "Type", types: [STEP_TYPE] },
-            { type: "Workspace", workspaceIds: [workspaceId] },
-            { type: "CustomAttributeValue", attribute: STEP_ATTR.wizardRef, operator: "equals", reference: wizard.uid }
-        ]
+            { type: 'Type', types: [STEP_TYPE] },
+            { type: 'Workspace', workspaceIds: [workspaceId] },
+            {
+                type: 'CustomAttributeValue',
+                attribute: STEP_ATTR.wizardRef,
+                operator: 'equals',
+                reference: wizard.uid,
+            },
+        ],
     };
     const searchResult = await client.makeApiRequest('json/search', 'GET', {
-        filter: JSON.stringify(stepFilter)
+        filter: JSON.stringify(stepFilter),
     });
     const stepPages = searchResult?.results || [];
     const steps = new Map();
@@ -112,7 +117,7 @@ async function resolveTypeInternalNames(client, workspaceId, typeInternalNames)
         debugLogWithTag('WIZARD_RESOLVE', `Resolving type '${internalName}' in workspace '${workspaceId}'`);
         const result = await client.makeApiRequest('json/type-definition', 'GET', {
             workspaceId,
-            internalName
+            internalName,
         });
         const uid = result.uid;
         if (!uid) {
@@ -124,7 +129,10 @@ async function resolveTypeInternalNames(client, workspaceId, typeInternalNames)
 }
 async function setWizardTriggerTypes(client, workspaceId, wizardUid, typeInternalNames) {
     try {
-        await client.makeApiRequest('json/wizard/triggerTypes', 'POST', undefined, { wizardId: stripPagePrefix(wizardUid), triggerTypes: typeInternalNames });
+        await client.makeApiRequest('json/wizard/triggerTypes', 'POST', undefined, {
+            wizardId: stripPagePrefix(wizardUid),
+            triggerTypes: typeInternalNames,
+        });
         debugLogWithTag('WIZARD_MANAGE', `Set triggerTypes via dedicated endpoint for wizard '${wizardUid}'`);
         return { method: 'endpoint' };
     }
@@ -133,16 +141,17 @@ async function setWizardTriggerTypes(client, workspaceId, wizardUid, typeInterna
         if (errorMsg.includes('404') || errorMsg.includes('Not Found')) {
             debugLogWithTag('WIZARD_MANAGE', `Dedicated triggerTypes endpoint not available, falling back to page API`);
             const resolvedUids = await resolveTypeInternalNames(client, workspaceId, typeInternalNames);
-            const bareIds = resolvedUids.map(uid => uid.replace(/^typeDefinition\//, ''));
+            const bareIds = resolvedUids.map((uid) => uid.replace(/^typeDefinition\//, ''));
             return { method: 'fallback', resolvedUids: bareIds };
         }
         throw error;
     }
 }
 function enhanceWizardError(errorMessage) {
-    if (errorMessage.includes('cf.cplace.formsWizard') && (errorMessage.includes('not found') ||
-        errorMessage.includes('Type definition not found') ||
-        errorMessage.includes('Ungültiger Wert'))) {
+    if (errorMessage.includes('cf.cplace.formsWizard') &&
+        (errorMessage.includes('not found') ||
+            errorMessage.includes('Type definition not found') ||
+            errorMessage.includes('Ungültiger Wert'))) {
         return `${errorMessage}\nHint: The Forms Wizard app may not be installed in this workspace. Use cplace_install_workspace_app with qualifiedName 'cf.cplace.formsWizard' to install it.`;
     }
     return errorMessage;
@@ -161,7 +170,7 @@ async function configureFormStepAttributes(client, configPageUid, formAttributes
         attributes: {
             [FORM_CONFIG_ATTR.typeNameToAttributesMapping]: typeNameToAttributesMapping,
             [FORM_CONFIG_ATTR.layout]: JSON.stringify(layout),
-        }
+        },
     });
 }
 function resolveStepTypeEnum(stepType) {
@@ -230,117 +239,175 @@ export const WIZARD_TOOL_DEFINITIONS = {
     [TOOL_MANAGE_WIZARD]: {
         description: "Create or update a Forms Wizard configuration. Wizards define multi-step guided workflows for data entry and process automation. Use 'create' to define a new wizard with display names, target workspaces, and behavior options. Use 'update' to modify an existing wizard's properties.",
         inputSchema: {
-            operation: z.enum(["create", "update"]).describe("Operation type: 'create' for new wizards, 'update' for existing wizards"),
-            workspaceId: z.string().describe("The workspace ID where the wizard lives (e.g., 'iwu7z9iscgr0')"),
-            wizardName: z.string().describe("For create: the name to give the wizard. For update: identifies the wizard to modify."),
-            localizedDisplayNames: z.record(z.string()).optional().describe("Localized display names (e.g., {\"en\": \"My Wizard\", \"de\": \"Mein Assistent\"})"),
-            description: z.string().optional().describe("Wizard description text"),
-            targetWorkspaces: z.array(z.string()).optional().describe("Workspace IDs where the wizard can be used"),
-            triggeringTypes: z.array(z.string()).optional().describe("Type internal names that trigger this wizard (e.g., ['cf.example.Task'])"),
-            autoPersist: z.boolean().optional().describe("Auto-persist changes after each step (default: false)"),
-            refreshAfterFinish: z.boolean().optional().describe("Refresh page after wizard finishes (default: false)"),
-            showProgressBar: z.boolean().optional().describe("Show progress bar during wizard execution"),
-            showPercent: z.boolean().optional().describe("Show percentage in progress bar"),
+            operation: z
+                .enum(['create', 'update'])
+                .describe("Operation type: 'create' for new wizards, 'update' for existing wizards"),
+            workspaceId: z
+                .string()
+                .describe("The workspace ID where the wizard lives (e.g., 'iwu7z9iscgr0')"),
+            wizardName: z
+                .string()
+                .describe('For create: the name to give the wizard. For update: identifies the wizard to modify.'),
+            localizedDisplayNames: z
+                .record(z.string())
+                .optional()
+                .describe('Localized display names (e.g., {"en": "My Wizard", "de": "Mein Assistent"})'),
+            description: z.string().optional().describe('Wizard description text'),
+            targetWorkspaces: z
+                .array(z.string())
+                .optional()
+                .describe('Workspace IDs where the wizard can be used'),
+            triggeringTypes: z
+                .array(z.string())
+                .optional()
+                .describe("Type internal names that trigger this wizard (e.g., ['cf.example.Task'])"),
+            autoPersist: z
+                .boolean()
+                .optional()
+                .describe('Auto-persist changes after each step (default: false)'),
+            refreshAfterFinish: z
+                .boolean()
+                .optional()
+                .describe('Refresh page after wizard finishes (default: false)'),
+            showProgressBar: z.boolean().optional().describe('Show progress bar during wizard execution'),
+            showPercent: z.boolean().optional().describe('Show percentage in progress bar'),
         },
-        annotations: { title: "Manage Wizard" }
+        annotations: { title: 'Manage Wizard' },
     },
     [TOOL_MANAGE_WIZARD_STEP]: {
-        description: "Create or update a wizard step. Steps are the individual screens in a wizard flow. Each step has a type (form, info, table, decision, script) that determines its behavior and configuration options. Step type is immutable after creation.",
+        description: 'Create or update a wizard step. Steps are the individual screens in a wizard flow. Each step has a type (form, info, table, decision, script) that determines its behavior and configuration options. Step type is immutable after creation.',
         inputSchema: {
-            operation: z.enum(["create", "update"]).describe("Operation type: 'create' for new steps, 'update' for existing steps"),
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the parent wizard"),
+            operation: z
+                .enum(['create', 'update'])
+                .describe("Operation type: 'create' for new steps, 'update' for existing steps"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the parent wizard'),
             identifier: z.string().describe("Unique step identifier (e.g., 'step-enter-details')"),
-            stepType: z.enum(["form", "info", "table", "decision", "script"]).optional().describe("Step type — required for create, rejected for update (immutable). Types: form (data entry), info (display content), table (search/select), decision (branching), script (automation)"),
-            title: z.record(z.string()).optional().describe("Localized step title (e.g., {\"en\": \"Enter Details\", \"de\": \"Details eingeben\"})"),
-            description: z.string().optional().describe("Step description (rich text/HTML)"),
-            targetTypes: z.array(z.string()).optional().describe("Form step: type internal names for data entry targets"),
-            formAttributes: z.record(z.array(z.string())).optional().describe("Form step: map of target type names to attribute arrays to display in the form. IMPORTANT: builtin attributes (e.g., \"name\") use bare identifiers, while custom attributes must be wrapped in single quotes (e.g., \"'test.parentProject'\"). Example: {\"test.project\": [\"name\", \"'test.parentProject'\", \"'test.managers'\"]}. Automatically configures the form step's child configuration page."),
+            stepType: z
+                .enum(['form', 'info', 'table', 'decision', 'script'])
+                .optional()
+                .describe('Step type — required for create, rejected for update (immutable). Types: form (data entry), info (display content), table (search/select), decision (branching), script (automation)'),
+            title: z
+                .record(z.string())
+                .optional()
+                .describe('Localized step title (e.g., {"en": "Enter Details", "de": "Details eingeben"})'),
+            description: z.string().optional().describe('Step description (rich text/HTML)'),
+            targetTypes: z
+                .array(z.string())
+                .optional()
+                .describe('Form step: type internal names for data entry targets'),
+            formAttributes: z
+                .record(z.array(z.string()))
+                .optional()
+                .describe('Form step: map of target type names to attribute arrays to display in the form. IMPORTANT: builtin attributes (e.g., "name") use bare identifiers, while custom attributes must be wrapped in single quotes (e.g., "\'test.parentProject\'"). Example: {"test.project": ["name", "\'test.parentProject\'", "\'test.managers\'"]}. Automatically configures the form step\'s child configuration page.'),
         },
-        annotations: { title: "Manage Wizard Step" }
+        annotations: { title: 'Manage Wizard Step' },
     },
     [TOOL_DELETE_WIZARD]: {
-        description: "Delete a wizard and optionally all its child steps. By default, cascade-deletes all steps. Set cascadeDeleteSteps to false to delete only the wizard page.",
+        description: 'Delete a wizard and optionally all its child steps. By default, cascade-deletes all steps. Set cascadeDeleteSteps to false to delete only the wizard page.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the wizard to delete"),
-            cascadeDeleteSteps: z.boolean().optional().default(true).describe("Delete all child steps too (default: true)"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the wizard to delete'),
+            cascadeDeleteSteps: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Delete all child steps too (default: true)'),
         },
-        annotations: { title: "Delete Wizard" }
+        annotations: { title: 'Delete Wizard' },
     },
     [TOOL_DELETE_WIZARD_STEP]: {
-        description: "Delete a single wizard step by its identifier. The step is removed from the wizard; any flow references to this step should be updated separately.",
+        description: 'Delete a single wizard step by its identifier. The step is removed from the wizard; any flow references to this step should be updated separately.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the parent wizard"),
-            identifier: z.string().describe("The identifier of the step to delete"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the parent wizard'),
+            identifier: z.string().describe('The identifier of the step to delete'),
         },
-        annotations: { title: "Delete Wizard Step" }
+        annotations: { title: 'Delete Wizard Step' },
     },
     [TOOL_CONFIGURE_WIZARD_FLOW]: {
-        description: "Configure the complete step flow graph for a wizard in a single call. Sets the start step, final steps, optional summary/cleanup steps, and all step-to-step connections. All referenced step identifiers must already exist.",
+        description: 'Configure the complete step flow graph for a wizard in a single call. Sets the start step, final steps, optional summary/cleanup steps, and all step-to-step connections. All referenced step identifiers must already exist.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the wizard to configure"),
-            startStep: z.string().describe("Identifier of the start step"),
-            finalSteps: z.array(z.string()).describe("Identifiers of final steps (wizard ends after these)"),
-            summaryStep: z.string().optional().describe("Identifier of the summary step (shown before finish)"),
-            cleanupScriptStep: z.string().optional().describe("Identifier of the cleanup script step (runs on finish)"),
-            stepConnections: z.array(z.object({
-                from: z.string().describe("Step identifier for the source step"),
-                nextSteps: z.array(z.string()).describe("Step identifiers for the next possible steps"),
-                skipTo: z.string().optional().describe("Step identifier to skip to"),
-                skipToFinish: z.boolean().optional().describe("Allow skipping to finish from this step"),
-                skipToLabel: z.record(z.string()).optional().describe("Localized label for skip-to button"),
-            })).describe("Connections between steps defining the flow graph"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the wizard to configure'),
+            startStep: z.string().describe('Identifier of the start step'),
+            finalSteps: z
+                .array(z.string())
+                .describe('Identifiers of final steps (wizard ends after these)'),
+            summaryStep: z
+                .string()
+                .optional()
+                .describe('Identifier of the summary step (shown before finish)'),
+            cleanupScriptStep: z
+                .string()
+                .optional()
+                .describe('Identifier of the cleanup script step (runs on finish)'),
+            stepConnections: z
+                .array(z.object({
+                from: z.string().describe('Step identifier for the source step'),
+                nextSteps: z.array(z.string()).describe('Step identifiers for the next possible steps'),
+                skipTo: z.string().optional().describe('Step identifier to skip to'),
+                skipToFinish: z
+                    .boolean()
+                    .optional()
+                    .describe('Allow skipping to finish from this step'),
+                skipToLabel: z
+                    .record(z.string())
+                    .optional()
+                    .describe('Localized label for skip-to button'),
+            }))
+                .describe('Connections between steps defining the flow graph'),
         },
-        annotations: { title: "Configure Wizard Flow" }
+        annotations: { title: 'Configure Wizard Flow' },
     },
     [TOOL_ACTIVATE_WIZARD]: {
-        description: "Activate or deactivate a wizard. On activation, runs the server-side analysis check (validates start step, final steps, step reachability, etc.). If activation fails, automatically runs analysis and returns detailed error information.",
+        description: 'Activate or deactivate a wizard. On activation, runs the server-side analysis check (validates start step, final steps, step reachability, etc.). If activation fails, automatically runs analysis and returns detailed error information.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the wizard to activate"),
-            activationState: z.enum(['ACTIVE', 'INACTIVE']).optional().describe("Target activation state (default: 'ACTIVE')"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the wizard to activate'),
+            activationState: z
+                .enum(['ACTIVE', 'INACTIVE'])
+                .optional()
+                .describe("Target activation state (default: 'ACTIVE')"),
         },
-        annotations: { title: "Activate Wizard" }
+        annotations: { title: 'Activate Wizard' },
     },
     [TOOL_GET_WIZARD_DETAILS]: {
-        description: "Get detailed information about a wizard including all its steps, flow configuration, and activation state. Returns structured wizard-domain data with step identifiers, types, and connections.",
+        description: 'Get detailed information about a wizard including all its steps, flow configuration, and activation state. Returns structured wizard-domain data with step identifiers, types, and connections.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
-            wizardName: z.string().describe("Name of the wizard to inspect"),
+            workspaceId: z.string().describe('The workspace ID where the wizard lives'),
+            wizardName: z.string().describe('Name of the wizard to inspect'),
         },
-        annotations: { title: "Get Wizard Details" }
+        annotations: { title: 'Get Wizard Details' },
     },
     [TOOL_LIST_WIZARDS]: {
-        description: "List all wizards in a workspace. Returns wizard names, display names, and basic configuration summary.",
+        description: 'List all wizards in a workspace. Returns wizard names, display names, and basic configuration summary.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID to search for wizards"),
+            workspaceId: z.string().describe('The workspace ID to search for wizards'),
         },
-        annotations: { title: "List Wizards" }
+        annotations: { title: 'List Wizards' },
     },
     [TOOL_ANALYZE_WIZARD]: {
-        description: "Run the wizard analysis checks without changing activation state. Returns results from all wizard-level analyzers (start step, step reachability, final steps, leaf nodes, skip configuration, external access) plus per-step type-specific analysis. Use this to validate wizard configuration before activation or to debug why activation fails.",
+        description: 'Run the wizard analysis checks without changing activation state. Returns results from all wizard-level analyzers (start step, step reachability, final steps, leaf nodes, skip configuration, external access) plus per-step type-specific analysis. Use this to validate wizard configuration before activation or to debug why activation fails.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard exists"),
-            wizardName: z.string().describe("The name of the wizard to analyze"),
+            workspaceId: z.string().describe('The workspace ID where the wizard exists'),
+            wizardName: z.string().describe('The name of the wizard to analyze'),
         },
-        annotations: { title: "Analyze Wizard Configuration" }
+        annotations: { title: 'Analyze Wizard Configuration' },
     },
     [TOOL_GET_WIZARD_ACTIVATION_STATE]: {
-        description: "Get the current activation state of a wizard without changing it. Returns whether the wizard is ACTIVE or INACTIVE, and whether the state can be changed. Use this for pre-flight checks before activation, or to monitor wizard states across workspaces.",
+        description: 'Get the current activation state of a wizard without changing it. Returns whether the wizard is ACTIVE or INACTIVE, and whether the state can be changed. Use this for pre-flight checks before activation, or to monitor wizard states across workspaces.',
         inputSchema: {
-            workspaceId: z.string().describe("The workspace ID where the wizard exists"),
-            wizardName: z.string().describe("The name of the wizard to check"),
+            workspaceId: z.string().describe('The workspace ID where the wizard exists'),
+            wizardName: z.string().describe('The name of the wizard to check'),
         },
-        annotations: { title: "Get Wizard Activation State" }
+        annotations: { title: 'Get Wizard Activation State' },
     },
 };
 export function registerWizardTools(server, client) {
     server.registerTool(TOOL_MANAGE_WIZARD, WIZARD_TOOL_DEFINITIONS[TOOL_MANAGE_WIZARD], async (params) => {
         try {
-            if (params.operation === "create") {
+            if (params.operation === 'create') {
                 const requestBody = {
                     workspaceId: params.workspaceId,
                     typeInternalName: WIZARD_TYPE,
@@ -371,12 +438,12 @@ export function registerWizardTools(server, client) {
                     if (ttResult.method === 'fallback' && ttResult.resolvedUids) {
                         await client.makeApiRequest('json/page', 'PATCH', undefined, {
                             pageUID: wizardUid,
-                            attributes: { [WIZARD_ATTR.triggeringTypes]: ttResult.resolvedUids }
+                            attributes: { [WIZARD_ATTR.triggeringTypes]: ttResult.resolvedUids },
                         });
                     }
                 }
                 return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
             else {
@@ -405,8 +472,8 @@ export function registerWizardTools(server, client) {
                 }
                 else if (!hasTriggerTypesUpdate) {
                     return {
-                        content: [{ type: "text", text: "No updates specified." }],
-                        isError: true
+                        content: [{ type: 'text', text: 'No updates specified.' }],
+                        isError: true,
                     };
                 }
                 if (hasTriggerTypesUpdate && params.triggeringTypes !== undefined) {
@@ -415,37 +482,49 @@ export function registerWizardTools(server, client) {
                         if (ttResult.method === 'fallback' && ttResult.resolvedUids) {
                             await client.makeApiRequest('json/page', 'PATCH', undefined, {
                                 pageUID: resolved.uid,
-                                attributes: { [WIZARD_ATTR.triggeringTypes]: ttResult.resolvedUids }
+                                attributes: { [WIZARD_ATTR.triggeringTypes]: ttResult.resolvedUids },
                             });
                         }
                     }
                     else {
                         await client.makeApiRequest('json/page', 'PATCH', undefined, {
                             pageUID: resolved.uid,
-                            attributes: { [WIZARD_ATTR.triggeringTypes]: params.triggeringTypes }
+                            attributes: { [WIZARD_ATTR.triggeringTypes]: params.triggeringTypes },
                         });
                     }
                 }
                 return {
-                    content: [{ type: "text", text: JSON.stringify({ status: 'updated', wizardName: params.wizardName, uid: resolved.uid }, null, 2) }]
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ status: 'updated', wizardName: params.wizardName, uid: resolved.uid }, null, 2),
+                        },
+                    ],
                 };
             }
         }
         catch (error) {
-            const operationText = params.operation === "create" ? "creating" : "updating";
+            const operationText = params.operation === 'create' ? 'creating' : 'updating';
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error ${operationText} wizard: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error ${operationText} wizard: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
     server.registerTool(TOOL_MANAGE_WIZARD_STEP, WIZARD_TOOL_DEFINITIONS[TOOL_MANAGE_WIZARD_STEP], async (params) => {
         try {
-            if (params.operation === "create") {
+            if (params.operation === 'create') {
                 if (!params.stepType) {
                     return {
-                        content: [{ type: "text", text: "Error: stepType is required for create operation" }],
-                        isError: true
+                        content: [
+                            { type: 'text', text: 'Error: stepType is required for create operation' },
+                        ],
+                        isError: true,
                     };
                 }
                 const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
@@ -479,14 +558,19 @@ export function registerWizardTools(server, client) {
                     }
                 }
                 return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
             else {
                 if (params.stepType !== undefined) {
                     return {
-                        content: [{ type: "text", text: "Error: stepType is immutable after creation. Create a new step instead." }],
-                        isError: true
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: stepType is immutable after creation. Create a new step instead.',
+                            },
+                        ],
+                        isError: true,
                     };
                 }
                 const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
@@ -494,8 +578,13 @@ export function registerWizardTools(server, client) {
                 if (!stepUid) {
                     const available = Array.from(resolved.steps.keys()).join(', ');
                     return {
-                        content: [{ type: "text", text: `Error: Step '${params.identifier}' not found. Available: ${available}` }],
-                        isError: true
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error: Step '${params.identifier}' not found. Available: ${available}`,
+                            },
+                        ],
+                        isError: true,
                     };
                 }
                 const requestBody = { pageUID: stepUid };
@@ -509,8 +598,8 @@ export function registerWizardTools(server, client) {
                 }
                 if (Object.keys(attributes).length === 0 && !params.formAttributes) {
                     return {
-                        content: [{ type: "text", text: "No updates specified." }],
-                        isError: true
+                        content: [{ type: 'text', text: 'No updates specified.' }],
+                        isError: true,
                     };
                 }
                 let result;
@@ -531,15 +620,20 @@ export function registerWizardTools(server, client) {
                     }
                 }
                 return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
         }
         catch (error) {
-            const operationText = params.operation === "create" ? "creating" : "updating";
+            const operationText = params.operation === 'create' ? 'creating' : 'updating';
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error ${operationText} wizard step: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error ${operationText} wizard step: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -550,23 +644,35 @@ export function registerWizardTools(server, client) {
             if (params.cascadeDeleteSteps !== false) {
                 const result = await client.makeApiRequest('json/page/with-children', 'DELETE', undefined, {
                     pageUID: resolved.uid,
-                    confirmDeleteChildren: true
+                    confirmDeleteChildren: true,
                 });
                 return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
             else {
-                const result = await client.makeApiRequest('json/page', 'DELETE', { pageUID: resolved.uid });
+                const result = await client.makeApiRequest('json/page', 'DELETE', {
+                    pageUID: resolved.uid,
+                });
                 return {
-                    content: [{ type: "text", text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) }]
+                    content: [
+                        {
+                            type: 'text',
+                            text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result),
+                        },
+                    ],
                 };
             }
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error deleting wizard: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error deleting wizard: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -577,23 +683,38 @@ export function registerWizardTools(server, client) {
             if (!stepUid) {
                 const available = Array.from(resolved.steps.keys()).join(', ');
                 return {
-                    content: [{ type: "text", text: `Error: Step '${params.identifier}' not found. Available: ${available}` }],
-                    isError: true
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Step '${params.identifier}' not found. Available: ${available}`,
+                        },
+                    ],
+                    isError: true,
                 };
             }
             debugLogWithTag('WIZARD_STEP_DELETE', `Deleting step '${params.identifier}' (${stepUid})`);
             const result = await client.makeApiRequest('json/page/with-children', 'DELETE', undefined, {
                 pageUID: stepUid,
-                confirmDeleteChildren: true
+                confirmDeleteChildren: true,
             });
             return {
-                content: [{ type: "text", text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) }]
+                content: [
+                    {
+                        type: 'text',
+                        text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result),
+                    },
+                ],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error deleting wizard step: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error deleting wizard step: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -605,22 +726,31 @@ export function registerWizardTools(server, client) {
                 ...params.finalSteps,
                 ...(params.summaryStep ? [params.summaryStep] : []),
                 ...(params.cleanupScriptStep ? [params.cleanupScriptStep] : []),
-                ...params.stepConnections.flatMap(c => [c.from, ...c.nextSteps, ...(c.skipTo ? [c.skipTo] : [])])
+                ...params.stepConnections.flatMap((c) => [
+                    c.from,
+                    ...c.nextSteps,
+                    ...(c.skipTo ? [c.skipTo] : []),
+                ]),
             ]);
             for (const id of allReferencedIds) {
                 if (!resolved.steps.has(id)) {
                     return {
-                        content: [{ type: "text", text: `Error: Step '${id}' not found. Available: ${Array.from(resolved.steps.keys()).join(', ')}` }],
-                        isError: true
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error: Step '${id}' not found. Available: ${Array.from(resolved.steps.keys()).join(', ')}`,
+                            },
+                        ],
+                        isError: true,
                     };
                 }
             }
             debugLogWithTag('WIZARD_FLOW', `Configuring flow for wizard '${params.wizardName}' with ${params.stepConnections.length} connections`);
             for (const conn of params.stepConnections) {
                 const stepUid = resolved.steps.get(conn.from);
-                const nextStepUids = conn.nextSteps.map(id => resolved.steps.get(id));
+                const nextStepUids = conn.nextSteps.map((id) => resolved.steps.get(id));
                 const attributes = {
-                    [STEP_ATTR.nextPossibleSteps]: nextStepUids
+                    [STEP_ATTR.nextPossibleSteps]: nextStepUids,
                 };
                 if (conn.skipTo)
                     attributes[STEP_ATTR.skipTo] = resolved.steps.get(conn.skipTo);
@@ -630,12 +760,12 @@ export function registerWizardTools(server, client) {
                     attributes[STEP_ATTR.skipToLabel] = conn.skipToLabel;
                 await client.makeApiRequest('json/page', 'PATCH', undefined, {
                     pageUID: stepUid,
-                    attributes
+                    attributes,
                 });
             }
             const wizardAttributes = {
                 [WIZARD_ATTR.startStep]: resolved.steps.get(params.startStep),
-                [WIZARD_ATTR.finalSteps]: params.finalSteps.map(id => resolved.steps.get(id)),
+                [WIZARD_ATTR.finalSteps]: params.finalSteps.map((id) => resolved.steps.get(id)),
             };
             if (params.summaryStep) {
                 wizardAttributes[WIZARD_ATTR.summaryStep] = resolved.steps.get(params.summaryStep);
@@ -645,21 +775,31 @@ export function registerWizardTools(server, client) {
             }
             await client.makeApiRequest('json/page', 'PATCH', undefined, {
                 pageUID: resolved.wizard.uid,
-                attributes: wizardAttributes
+                attributes: wizardAttributes,
             });
             return {
-                content: [{ type: "text", text: JSON.stringify({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
                             configured: true,
                             wizardName: params.wizardName,
                             stepCount: resolved.steps.size,
-                            connectionCount: params.stepConnections.length
-                        }, null, 2) }]
+                            connectionCount: params.stepConnections.length,
+                        }, null, 2),
+                    },
+                ],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error configuring wizard flow: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error configuring wizard flow: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -667,48 +807,70 @@ export function registerWizardTools(server, client) {
         try {
             const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
             debugLogWithTag('WIZARD_ACTIVATE', `Activating wizard '${params.wizardName}' (${resolved.uid})`);
-            const response = await client.makeApiRequest('json/wizard/activation', 'POST', undefined, { wizardId: stripPagePrefix(resolved.uid), activationState: params.activationState || 'ACTIVE' });
+            const response = await client.makeApiRequest('json/wizard/activation', 'POST', undefined, {
+                wizardId: stripPagePrefix(resolved.uid),
+                activationState: params.activationState || 'ACTIVE',
+            });
             if (response?.activationState === 'ACTIVE' || response?.activationState === 'INACTIVE') {
                 return {
-                    content: [{ type: "text", text: JSON.stringify({
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
                                 status: response.activationState === 'ACTIVE' ? 'activated' : 'deactivated',
                                 wizardName: params.wizardName,
                                 activationState: response.activationState,
-                                canChangeState: response.canChangeState
-                            }, null, 2) }]
+                                canChangeState: response.canChangeState,
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
             else {
                 debugLogWithTag('WIZARD_ACTIVATE', `Activation failed, running analysis for wizard '${params.wizardName}'`);
                 let analysisResults = null;
                 try {
-                    analysisResults = await client.makeApiRequest('json/wizard/analysis', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+                    analysisResults = await client.makeApiRequest('json/wizard/analysis', 'GET', {
+                        wizardId: stripPagePrefix(resolved.uid),
+                    });
                 }
                 catch (analysisError) {
                     debugLogWithTag('WIZARD_ACTIVATE', `Auto-analysis also failed: ${analysisError}`);
                 }
                 return {
-                    content: [{ type: "text", text: JSON.stringify({
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
                                 status: 'failed',
                                 wizardName: params.wizardName,
                                 error: response || 'Activation failed — state was not changed',
-                                ...(analysisResults ? { analysisResults } : {})
-                            }, null, 2) }],
-                    isError: true
+                                ...(analysisResults ? { analysisResults } : {}),
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
                 };
             }
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: enhanceWizardError(`Error activating wizard: ${error instanceof Error ? error.message : String(error)}`) }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: enhanceWizardError(`Error activating wizard: ${error instanceof Error ? error.message : String(error)}`),
+                    },
+                ],
+                isError: true,
             };
         }
     });
     server.registerTool(TOOL_GET_WIZARD_DETAILS, WIZARD_TOOL_DEFINITIONS[TOOL_GET_WIZARD_DETAILS], async (params) => {
         try {
             const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
-            const wizardPage = await client.makeApiRequest('json/page', 'GET', { pageUID: resolved.wizard.uid });
+            const wizardPage = await client.makeApiRequest('json/page', 'GET', {
+                pageUID: resolved.wizard.uid,
+            });
             const stepDetails = [];
             for (const [identifier, uid] of resolved.steps) {
                 const stepPage = await client.makeApiRequest('json/page', 'GET', { pageUID: uid });
@@ -716,30 +878,35 @@ export function registerWizardTools(server, client) {
                     identifier,
                     uid,
                     name: stepPage.name,
-                    ...extractStepSummary(stepPage)
+                    ...extractStepSummary(stepPage),
                 });
             }
             const result = {
                 wizardName: params.wizardName,
                 uid: resolved.wizard.uid,
                 ...extractWizardSummary(wizardPage),
-                steps: stepDetails
+                steps: stepDetails,
             };
             const sizeCheck = checkResponseSize(result);
             if (sizeCheck.tooLarge) {
                 return {
-                    content: [{ type: "text", text: sizeCheck.suggestion }],
-                    isError: true
+                    content: [{ type: 'text', text: sizeCheck.suggestion }],
+                    isError: true,
                 };
             }
             return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Error getting wizard details: ${error instanceof Error ? error.message : String(error)}` }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error getting wizard details: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -747,34 +914,39 @@ export function registerWizardTools(server, client) {
         try {
             const listFilter = {
                 filters: [
-                    { type: "Type", types: [WIZARD_TYPE] },
-                    { type: "Workspace", workspaceIds: [params.workspaceId] }
-                ]
+                    { type: 'Type', types: [WIZARD_TYPE] },
+                    { type: 'Workspace', workspaceIds: [params.workspaceId] },
+                ],
             };
             const searchResult = await client.makeApiRequest('json/search', 'GET', {
-                filter: JSON.stringify(listFilter)
+                filter: JSON.stringify(listFilter),
             });
             const wizards = (searchResult?.results || []).map((page) => ({
                 name: page.name,
                 uid: page.uid || page.id,
-                ...extractWizardListSummary(page)
+                ...extractWizardListSummary(page),
             }));
             const result = { wizards, count: wizards.length };
             const sizeCheck = checkResponseSize(result);
             if (sizeCheck.tooLarge) {
                 return {
-                    content: [{ type: "text", text: sizeCheck.suggestion }],
-                    isError: true
+                    content: [{ type: 'text', text: sizeCheck.suggestion }],
+                    isError: true,
                 };
             }
             return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Error listing wizards: ${error instanceof Error ? error.message : String(error)}` }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error listing wizards: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -782,25 +954,37 @@ export function registerWizardTools(server, client) {
         try {
             const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
             debugLogWithTag('WIZARD_ANALYZE', `Analyzing wizard '${params.wizardName}' (${resolved.uid})`);
-            const response = await client.makeApiRequest('json/wizard/analysis', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+            const response = await client.makeApiRequest('json/wizard/analysis', 'GET', {
+                wizardId: stripPagePrefix(resolved.uid),
+            });
             const sizeCheck = checkResponseSize(response);
             if (sizeCheck.tooLarge) {
                 return {
-                    content: [{ type: "text", text: sizeCheck.suggestion }],
-                    isError: true
+                    content: [{ type: 'text', text: sizeCheck.suggestion }],
+                    isError: true,
                 };
             }
             return {
-                content: [{ type: "text", text: JSON.stringify({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
                             wizardName: params.wizardName,
-                            analysisResults: response
-                        }, null, 2) }]
+                            analysisResults: response,
+                        }, null, 2),
+                    },
+                ],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Error analyzing wizard: ${error instanceof Error ? error.message : String(error)}` }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error analyzing wizard: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
             };
         }
     });
@@ -808,26 +992,38 @@ export function registerWizardTools(server, client) {
         try {
             const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
             debugLogWithTag('WIZARD_ACTIVATION_STATE', `Getting activation state for wizard '${params.wizardName}' (${resolved.uid})`);
-            const response = await client.makeApiRequest('json/wizard/activation', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+            const response = await client.makeApiRequest('json/wizard/activation', 'GET', {
+                wizardId: stripPagePrefix(resolved.uid),
+            });
             const sizeCheck = checkResponseSize(response);
             if (sizeCheck.tooLarge) {
                 return {
-                    content: [{ type: "text", text: sizeCheck.suggestion }],
-                    isError: true
+                    content: [{ type: 'text', text: sizeCheck.suggestion }],
+                    isError: true,
                 };
             }
             return {
-                content: [{ type: "text", text: JSON.stringify({
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
                             wizardName: params.wizardName,
                             activationState: response.activationState,
-                            canChangeState: response.canChangeState
-                        }, null, 2) }]
+                            canChangeState: response.canChangeState,
+                        }, null, 2),
+                    },
+                ],
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Error getting wizard activation state: ${error instanceof Error ? error.message : String(error)}` }],
-                isError: true
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error getting wizard activation state: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
             };
         }
     });