@synergy-design-system/mcp 3.6.0 → 3.8.0

package/dist/tools/index.js

@@ -7,6 +7,11 @@ export * from './davinci-migration-info.js';
 export * from './davinci-migration-list.js';
 export * from './migration-info.js';
 export * from './migration-list.js';
+export * from './intent-categories-list.js';
+export * from './intent-component-guide.js';
+export * from './intent-component-validate.js';
+export * from './intent-task-recommendations.js';
+export * from './intent-options.js';
 export * from './setup.js';
 export * from './styles-info.js';
 export * from './styles-list.js';

package/dist/tools/intent-categories-list.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Lists available intent categories from the experimental intent policy layer.
+ * @param server The MCP server instance used for tool registration.
+ */
+export declare const intentCategoriesListTool: (server: McpServer) => void;

package/dist/tools/intent-categories-list.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { experimental_listIntentCategories as listIntentCategories, } from '@synergy-design-system/metadata';
+import { INTENT_DEFAULT_PHASES, createToolAnnotations, getRuntimeConfig, getToolRule, intentPhaseSchema, toolHandler, } from '../utilities/index.js';
+/**
+ * Lists available intent categories from the experimental intent policy layer.
+ * @param server The MCP server instance used for tool registration.
+ */
+export const intentCategoriesListTool = (server) => {
+    server.registerTool('intent-categories-list', {
+        annotations: createToolAnnotations(),
+        description: 'List available intent categories in the intent policy layer.',
+        inputSchema: {
+            includePhases: z.array(intentPhaseSchema).optional().describe('Optional phase filter. Defaults to ["experimental"].'),
+        },
+        title: 'Intent categories list',
+    }, toolHandler('intent-categories-list', async ({ includePhases, }) => {
+        const toolDefaults = getRuntimeConfig().tools.intentCategoriesList;
+        const aiRules = await getToolRule('intent-categories-list');
+        const response = await listIntentCategories({}, { includePhases: includePhases ?? toolDefaults.includePhases ?? [...INTENT_DEFAULT_PHASES] });
+        if (!response.data) {
+            const message = response.errors?.[0]?.message ?? 'No intent categories found.';
+            return [aiRules, message];
+        }
+        return [aiRules, response.data];
+    }));
+};

package/dist/tools/intent-component-guide.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Returns intent-focused usage guidance for a component.
+ * @param server The MCP server instance used for tool registration.
+ */
+export declare const intentComponentGuideTool: (server: McpServer) => void;

package/dist/tools/intent-component-guide.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { experimental_getComponentGuide as getComponentGuide, } from '@synergy-design-system/metadata';
+import { INTENT_DEFAULT_FRAMEWORK, INTENT_DEFAULT_PHASES, createToolAnnotations, getRuntimeConfig, getToolRule, intentFrameworkSchema, intentPhaseSchema, toolHandler, } from '../utilities/index.js';
+const frameworkSchema = intentFrameworkSchema;
+/**
+ * Returns intent-focused usage guidance for a component.
+ * @param server The MCP server instance used for tool registration.
+ */
+export const intentComponentGuideTool = (server) => {
+    server.registerTool('intent-component-guide', {
+        annotations: createToolAnnotations(),
+        description: 'Answer the question: What can I do with this component in the intent system?',
+        inputSchema: {
+            component: z.string().startsWith('syn-').describe('Component tag name, for example syn-button.'),
+            framework: frameworkSchema.optional().describe('Target framework profile. Defaults to vanilla.'),
+            includePhases: z.array(intentPhaseSchema).optional().describe('Optional phase filter. Defaults to ["experimental"].'),
+        },
+        title: 'Intent component guide',
+    }, toolHandler('intent-component-guide', async ({ component, framework, includePhases, }) => {
+        const toolDefaults = getRuntimeConfig().tools.intentComponentGuide;
+        const aiRules = await getToolRule('intent-component-guide');
+        const response = await getComponentGuide({
+            component,
+            framework: framework ?? toolDefaults.framework ?? INTENT_DEFAULT_FRAMEWORK,
+            includePhases: includePhases ?? toolDefaults.includePhases ?? [...INTENT_DEFAULT_PHASES],
+        });
+        if (!response.data) {
+            const message = response.errors?.[0]?.message ?? `No intent guide found for component ${component}.`;
+            return [aiRules, message];
+        }
+        return [aiRules, response.data];
+    }));
+};

package/dist/tools/intent-component-validate.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Validates whether a component usage matches intent rules.
+ * @param server The MCP server instance used for tool registration.
+ */
+export declare const intentComponentValidateTool: (server: McpServer) => void;

package/dist/tools/intent-component-validate.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import { experimental_validateComponent as validateComponent, } from '@synergy-design-system/metadata';
+import { INTENT_DEFAULT_FRAMEWORK, INTENT_DEFAULT_PHASES, createToolAnnotations, getRuntimeConfig, getToolRule, intentFrameworkSchema, intentPhaseSchema, toolHandler, } from '../utilities/index.js';
+const frameworkSchema = intentFrameworkSchema;
+const parsePrimitiveValue = (rawValue, isBinding) => {
+    if (rawValue === undefined) {
+        return true;
+    }
+    const value = rawValue.trim();
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    if (value === 'null') {
+        return null;
+    }
+    if (isBinding && /^-?\d+(\.\d+)?$/.test(value)) {
+        return Number(value);
+    }
+    return value;
+};
+const parseAttribute = (match) => {
+    const rawName = match[1] ?? '';
+    const rawValue = match[2] ?? match[3] ?? match[4];
+    const shouldSkip = rawName.startsWith('(')
+        || rawName.startsWith('#')
+        || rawName.startsWith('*')
+        || rawName.startsWith('@');
+    const bracketBinding = rawName.startsWith('[') && rawName.endsWith(']');
+    const withoutBrackets = bracketBinding ? rawName.slice(1, -1) : rawName;
+    const normalizedName = withoutBrackets.startsWith('attr.')
+        ? withoutBrackets.slice(5)
+        : withoutBrackets;
+    return {
+        isBinding: bracketBinding,
+        name: normalizedName,
+        rawValue,
+        shouldSkip,
+    };
+};
+const parseAttributes = (source) => {
+    const attrPattern = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    const matches = Array.from(source.matchAll(attrPattern));
+    const reduced = matches.reduce((acc, match) => {
+        const parsed = parseAttribute(match);
+        if (parsed.shouldSkip) {
+            return acc;
+        }
+        if (parsed.name === 'class') {
+            if (parsed.rawValue) {
+                acc.classes.push(...parsed.rawValue.split(/\s+/).filter(Boolean));
+            }
+            return acc;
+        }
+        if (parsed.name === 'role') {
+            acc.role = parsed.rawValue ?? 'true';
+            return acc;
+        }
+        if (parsed.name === 'slot') {
+            acc.slot = parsed.rawValue ?? 'true';
+            return acc;
+        }
+        acc.props[parsed.name] = parsePrimitiveValue(parsed.rawValue, parsed.isBinding);
+        return acc;
+    }, {
+        classes: [],
+        props: {},
+    });
+    return {
+        ...(reduced.classes.length > 0 ? { classes: Array.from(new Set(reduced.classes)) } : {}),
+        ...(Object.keys(reduced.props).length > 0 ? { props: reduced.props } : {}),
+        ...(reduced.role ? { role: reduced.role } : {}),
+        ...(reduced.slot ? { slot: reduced.slot } : {}),
+    };
+};
+const findFirstNodeByComponent = (nodes, component) => {
+    const directMatch = nodes.find((node) => node.component === component);
+    if (directMatch) {
+        return directMatch;
+    }
+    return nodes
+        .map((node) => (node.children && node.children.length > 0 ? findFirstNodeByComponent(node.children, component) : undefined))
+        .find((node) => Boolean(node));
+};
+const parseMarkupToStructure = (markup) => {
+    const tokenPattern = /<!--[\s\S]*?-->|<\/?[a-zA-Z][\w:-]*\b[^>]*\/?>|[^<]+/g;
+    const root = { children: [], component: '__root__' };
+    const stack = [root];
+    const tokens = markup.match(tokenPattern) ?? [];
+    tokens.forEach((token) => {
+        const currentParent = stack[stack.length - 1];
+        if (token && !token.startsWith('<!--') && token.startsWith('</')) {
+            const closeName = token.slice(2, -1).trim().toLowerCase();
+            while (stack.length > 1) {
+                const top = stack.pop();
+                if (top?.component.toLowerCase() === closeName) {
+                    break;
+                }
+            }
+        }
+        else if (token && !token.startsWith('<!--') && token.startsWith('<')) {
+            const openMatch = token.match(/^<([a-zA-Z][\w:-]*)([^>]*)\/?>(?:\s*)$/);
+            if (openMatch) {
+                const tagName = (openMatch[1] ?? '').toLowerCase();
+                const attrSource = openMatch[2] ?? '';
+                const isSelfClosing = token.endsWith('/>');
+                const node = {
+                    component: tagName,
+                    ...parseAttributes(attrSource),
+                };
+                currentParent.children = currentParent.children ?? [];
+                currentParent.children.push(node);
+                if (!isSelfClosing) {
+                    stack.push(node);
+                }
+            }
+        }
+        else if (token && !token.startsWith('<!--')) {
+            const normalizedText = token.replace(/\s+/g, ' ').trim();
+            if (!normalizedText) {
+                return;
+            }
+            currentParent.children = currentParent.children ?? [];
+            currentParent.children.push({ component: 'text', text: normalizedText });
+        }
+    });
+    return root.children ?? [];
+};
+/**
+ * Validates whether a component usage matches intent rules.
+ * @param server The MCP server instance used for tool registration.
+ */
+export const intentComponentValidateTool = (server) => {
+    server.registerTool('intent-component-validate', {
+        annotations: createToolAnnotations(),
+        description: 'Answer the question: Do I use a component correctly for a specific intent?',
+        inputSchema: {
+            component: z.string().startsWith('syn-').describe('Component tag name, for example syn-button.'),
+            framework: frameworkSchema.optional().describe('Target framework profile. Defaults to vanilla.'),
+            includePhases: z.array(intentPhaseSchema).optional().describe('Optional phase filter. Defaults to ["experimental"].'),
+            intent: z.string().min(1).describe('Intent ID, for example action.submit.'),
+            markup: z.string().min(1).describe('Template or markup source. The tool auto-derives structure for validation from this content.'),
+        },
+        title: 'Intent component validate',
+    }, toolHandler('intent-component-validate', async ({ component, framework, includePhases, intent, markup, }) => {
+        const { tools } = getRuntimeConfig();
+        const aiRules = await getToolRule('intent-component-validate');
+        const parsedNodes = parseMarkupToStructure(markup);
+        const normalizedStructure = findFirstNodeByComponent(parsedNodes, component)
+            ?? {
+                children: parsedNodes,
+                component,
+            };
+        const response = await validateComponent({
+            component,
+            framework: framework ?? tools.intentComponentValidate.framework ?? INTENT_DEFAULT_FRAMEWORK,
+            includePhases: includePhases ?? tools.intentComponentValidate.includePhases ?? [...INTENT_DEFAULT_PHASES],
+            intent,
+            structure: normalizedStructure,
+        });
+        if (!response.data) {
+            const message = response.errors?.[0]?.message ?? `No validation result available for component ${component}.`;
+            return [aiRules, message];
+        }
+        return [aiRules, response.data];
+    }));
+};

package/dist/tools/intent-options.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Returns renderable target options for a specific intent.
+ * @param server The MCP server instance used for tool registration.
+ */
+export declare const intentOptionsTool: (server: McpServer) => void;

package/dist/tools/intent-options.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { experimental_getIntentOptions as getIntentOptions, } from '@synergy-design-system/metadata';
+import { INTENT_DEFAULT_FRAMEWORK, INTENT_DEFAULT_PHASES, createToolAnnotations, getRuntimeConfig, getToolRule, intentFrameworkSchema, intentPhaseSchema, toolHandler, } from '../utilities/index.js';
+const frameworkSchema = intentFrameworkSchema;
+/**
+ * Returns renderable target options for a specific intent.
+ * @param server The MCP server instance used for tool registration.
+ */
+export const intentOptionsTool = (server) => {
+    server.registerTool('intent-options', {
+        annotations: createToolAnnotations(),
+        description: 'Answer the question: What are my renderable options for a specific intent?',
+        inputSchema: {
+            content: z.string().optional().describe('Optional content used in preview snippets.'),
+            framework: frameworkSchema.optional().describe('Target framework profile. Defaults to vanilla.'),
+            includeDiagnostics: z.boolean().optional().describe('Include non-renderable candidates for diagnostics.'),
+            includePhases: z.array(intentPhaseSchema).optional().describe('Optional phase filter. Defaults to ["experimental"].'),
+            intentId: z
+                .string()
+                .min(1)
+                .describe('Intent ID to resolve, for example action.submit. Can be obtained by calling intent-categories-list tool.'),
+            maxAlternatives: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe('Maximum number of alternatives.'),
+        },
+        title: 'Intent options',
+    }, toolHandler('intent-options', async ({ content, framework, includeDiagnostics, includePhases, intentId, maxAlternatives, }) => {
+        const { tools } = getRuntimeConfig();
+        const aiRules = await getToolRule('intent-options');
+        const response = await getIntentOptions({
+            content,
+            framework: framework ?? tools.intentOptions.framework ?? INTENT_DEFAULT_FRAMEWORK,
+            includeDiagnostics: includeDiagnostics ?? tools.intentOptions.includeDiagnostics,
+            includePhases: includePhases ?? tools.intentOptions.includePhases ?? [...INTENT_DEFAULT_PHASES],
+            intentId,
+            maxAlternatives: maxAlternatives ?? tools.intentOptions.maxAlternatives,
+        });
+        if (!response.data) {
+            const message = response.errors?.[0]?.message ?? `No intent options found for ${intentId}.`;
+            return [aiRules, message];
+        }
+        return [aiRules, response.data];
+    }));
+};

package/dist/tools/intent-task-recommendations.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Recommends components for a task represented by an intent ID.
+ * @param server The MCP server instance used for tool registration.
+ */
+export declare const intentTaskRecommendationsTool: (server: McpServer) => void;

package/dist/tools/intent-task-recommendations.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { experimental_findComponentsForTask as findComponentsForTask, } from '@synergy-design-system/metadata';
+import { INTENT_DEFAULT_FRAMEWORK, INTENT_DEFAULT_PHASES, createToolAnnotations, getRuntimeConfig, getToolRule, intentFrameworkSchema, intentPhaseSchema, toolHandler, } from '../utilities/index.js';
+const frameworkSchema = intentFrameworkSchema;
+/**
+ * Recommends components for a task represented by an intent ID.
+ * @param server The MCP server instance used for tool registration.
+ */
+export const intentTaskRecommendationsTool = (server) => {
+    server.registerTool('intent-task-recommendations', {
+        annotations: createToolAnnotations(),
+        description: 'Answer the question: What does Synergy provide for a specific task intent?',
+        inputSchema: {
+            avoidTargets: z.array(z.string()).optional().describe('Optional target IDs to avoid.'),
+            content: z.string().optional().describe('Optional content used in render snippets.'),
+            framework: frameworkSchema.optional().describe('Target framework profile. Defaults to vanilla.'),
+            includePhases: z.array(intentPhaseSchema).optional().describe('Optional phase filter. Defaults to ["experimental"].'),
+            maxAlternatives: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe('Maximum number of alternatives.'),
+            preferredTargets: z.array(z.string()).optional().describe('Optional preferred target IDs for ranking.'),
+            taskId: z
+                .string()
+                .min(1)
+                .describe('Intent ID representing the task, for example action.submit. Can be obtained by calling intent-categories-list tool.'),
+        },
+        title: 'Intent task recommendations',
+    }, toolHandler('intent-task-recommendations', async ({ avoidTargets, content, framework, includePhases, maxAlternatives, preferredTargets, taskId, }) => {
+        const { tools } = getRuntimeConfig();
+        const aiRules = await getToolRule('intent-task-recommendations');
+        const hasConstraints = Boolean((preferredTargets && preferredTargets.length > 0)
+            || (avoidTargets && avoidTargets.length > 0));
+        const response = await findComponentsForTask({
+            constraints: hasConstraints ? {
+                avoidTargets,
+                preferredTargets,
+            } : undefined,
+            content,
+            framework: framework ?? tools.intentTaskRecommendations.framework ?? INTENT_DEFAULT_FRAMEWORK,
+            includePhases: includePhases ?? tools.intentTaskRecommendations.includePhases ?? [...INTENT_DEFAULT_PHASES],
+            maxAlternatives: maxAlternatives ?? tools.intentTaskRecommendations.maxAlternatives,
+            taskId,
+        });
+        if (!response.data) {
+            const message = response.errors?.[0]?.message ?? `No recommendations found for task ${taskId}.`;
+            return [aiRules, message];
+        }
+        return [aiRules, response.data];
+    }));
+};

package/dist/types/prompt-response.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PromptResponse type from MCP SDK representing a prompt response.
+ * Contains description and messages for the prompt result.
+ */
+export type PromptResponse = {
+    description: string;
+    messages: Array<{
+        content: {
+            text: string;
+            type: 'text';
+        };
+        role: 'user' | 'assistant';
+    }>;
+};

package/dist/types/prompt-response.js

@@ -0,0 +1 @@
+export {};

package/dist/utilities/config.d.ts

@@ -8,6 +8,7 @@ export declare const McpRuntimeConfigSchema: z.ZodObject<{
         none: "none";
         toon: "toon";
     }>>;
+    experimentalFeatures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     host: z.ZodDefault<z.ZodString>;
     includeAiRules: z.ZodDefault<z.ZodBoolean>;
     interface: z.ZodDefault<z.ZodEnum<{
@@ -45,14 +46,15 @@ export declare const McpRuntimeConfigSchema: z.ZodObject<{
         componentInfo: z.ZodDefault<z.ZodObject<{
             framework: z.ZodDefault<z.ZodEnum<{
                 angular: "angular";
-                react: "react";
                 vue: "vue";
                 vanilla: "vanilla";
+                react: "react";
             }>>;
             layer: z.ZodDefault<z.ZodEnum<{
                 full: "full";
                 examples: "examples";
                 interface: "interface";
+                rules: "rules";
             }>>;
         }, z.core.$strip>>;
         davinciMigrationInfo: z.ZodDefault<z.ZodObject<{
@@ -67,6 +69,77 @@ export declare const McpRuntimeConfigSchema: z.ZodObject<{
                 "dashboard-elements": "dashboard-elements";
             }>>;
         }, z.core.$strip>>;
+        intentCategoriesList: z.ZodDefault<z.ZodObject<{
+            includePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                stable: "stable";
+                deprecated: "deprecated";
+                experimental: "experimental";
+                preview: "preview";
+            }>>>;
+        }, z.core.$strip>>;
+        intentComponentGuide: z.ZodDefault<z.ZodObject<{
+            framework: z.ZodDefault<z.ZodEnum<{
+                "react-wrapper": "react-wrapper";
+                "react-web-components": "react-web-components";
+                angular: "angular";
+                vue: "vue";
+                vanilla: "vanilla";
+            }>>;
+            includePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                stable: "stable";
+                deprecated: "deprecated";
+                experimental: "experimental";
+                preview: "preview";
+            }>>>;
+        }, z.core.$strip>>;
+        intentComponentValidate: z.ZodDefault<z.ZodObject<{
+            framework: z.ZodDefault<z.ZodEnum<{
+                "react-wrapper": "react-wrapper";
+                "react-web-components": "react-web-components";
+                angular: "angular";
+                vue: "vue";
+                vanilla: "vanilla";
+            }>>;
+            includePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                stable: "stable";
+                deprecated: "deprecated";
+                experimental: "experimental";
+                preview: "preview";
+            }>>>;
+        }, z.core.$strip>>;
+        intentOptions: z.ZodDefault<z.ZodObject<{
+            framework: z.ZodDefault<z.ZodEnum<{
+                "react-wrapper": "react-wrapper";
+                "react-web-components": "react-web-components";
+                angular: "angular";
+                vue: "vue";
+                vanilla: "vanilla";
+            }>>;
+            includeDiagnostics: z.ZodDefault<z.ZodBoolean>;
+            includePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                stable: "stable";
+                deprecated: "deprecated";
+                experimental: "experimental";
+                preview: "preview";
+            }>>>;
+            maxAlternatives: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        intentTaskRecommendations: z.ZodDefault<z.ZodObject<{
+            framework: z.ZodDefault<z.ZodEnum<{
+                "react-wrapper": "react-wrapper";
+                "react-web-components": "react-web-components";
+                angular: "angular";
+                vue: "vue";
+                vanilla: "vanilla";
+            }>>;
+            includePhases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                stable: "stable";
+                deprecated: "deprecated";
+                experimental: "experimental";
+                preview: "preview";
+            }>>>;
+            maxAlternatives: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         migrationInfo: z.ZodDefault<z.ZodObject<{
             synergyPackage: z.ZodDefault<z.ZodEnum<{
                 components: "components";

package/dist/utilities/config.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
+import { INTENT_DEFAULT_FRAMEWORK, INTENT_DEFAULT_PHASES, INTENT_FRAMEWORK_VALUES, INTENT_PHASE_VALUES, } from './intent.js';
 /**
  * Zod schema for the synergy-mcp.json configuration file.
  * All fields are optional and fall back to built-in defaults when absent.
@@ -12,6 +13,18 @@ export const McpRuntimeConfigSchema = z.object({
      * @default 'none'
      */
     compression: z.enum(['none', 'toon']).default('none'),
+    /**
+     * Experimental feature toggles.
+     *
+     * Tools or capabilities guarded by these flags are disabled unless
+     * explicitly enabled.
+     *
+     * Known keys:
+     * - intentTools: Enables experimental intent MCP tools.
+     *
+     * @default {}
+     */
+    experimentalFeatures: z.record(z.string(), z.boolean()).default({}),
     /**
      * HTTP server host/interface when interface is 'http'.
      * Use 127.0.0.1 for local-only access or 0.0.0.0 to listen on all IPv4 interfaces.
@@ -110,7 +123,7 @@ export const McpRuntimeConfigSchema = z.object({
              * Default metadata layer when no layer is provided by the caller.
              * @default 'interface'
              */
-            layer: z.enum(['full', 'examples', 'interface']).default('interface'),
+            layer: z.enum(['full', 'examples', 'interface', 'rules']).default('interface'),
         }).default({ framework: 'vanilla', layer: 'interface' }),
         davinciMigrationInfo: z.object({
             /**
@@ -126,6 +139,101 @@ export const McpRuntimeConfigSchema = z.object({
              */
             package: z.enum(['basic-elements', 'dashboard-elements']).default('basic-elements'),
         }).default({ package: 'basic-elements' }),
+        intentCategoriesList: z.object({
+            /**
+             * Default intent phases when none are provided by the caller.
+             * @default ['experimental']
+             */
+            includePhases: z.array(z.enum(INTENT_PHASE_VALUES)).default([...INTENT_DEFAULT_PHASES]),
+        }).default({ includePhases: [...INTENT_DEFAULT_PHASES] }),
+        intentComponentGuide: z.object({
+            /**
+             * Default framework when no framework is provided by the caller.
+             * @default 'vanilla'
+             */
+            framework: z.enum(INTENT_FRAMEWORK_VALUES).default(INTENT_DEFAULT_FRAMEWORK),
+            /**
+             * Default intent phases when none are provided by the caller.
+             * @default ['experimental']
+             */
+            includePhases: z.array(z.enum(INTENT_PHASE_VALUES)).default([...INTENT_DEFAULT_PHASES]),
+        }).default({
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+        }),
+        intentComponentValidate: z.object({
+            /**
+             * Default framework when no framework is provided by the caller.
+             * @default 'vanilla'
+             */
+            framework: z.enum(INTENT_FRAMEWORK_VALUES).default(INTENT_DEFAULT_FRAMEWORK),
+            /**
+             * Default intent phases when none are provided by the caller.
+             * @default ['experimental']
+             */
+            includePhases: z.array(z.enum(INTENT_PHASE_VALUES)).default([...INTENT_DEFAULT_PHASES]),
+        }).default({
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+        }),
+        intentOptions: z.object({
+            /**
+             * Default framework when no framework is provided by the caller.
+             * @default 'vanilla'
+             */
+            framework: z.enum(INTENT_FRAMEWORK_VALUES).default(INTENT_DEFAULT_FRAMEWORK),
+            /**
+             * Include non-renderable candidates by default.
+             * @default false
+             */
+            includeDiagnostics: z.boolean().default(false),
+            /**
+             * Default intent phases when none are provided by the caller.
+             * @default ['experimental']
+             */
+            includePhases: z.array(z.enum(INTENT_PHASE_VALUES)).default([...INTENT_DEFAULT_PHASES]),
+            /**
+             * Default maximum number of alternatives.
+             * @default 5
+             */
+            maxAlternatives: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .default(5),
+        }).default({
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includeDiagnostics: false,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+            maxAlternatives: 5,
+        }),
+        intentTaskRecommendations: z.object({
+            /**
+             * Default framework when no framework is provided by the caller.
+             * @default 'vanilla'
+             */
+            framework: z.enum(INTENT_FRAMEWORK_VALUES).default(INTENT_DEFAULT_FRAMEWORK),
+            /**
+             * Default intent phases when none are provided by the caller.
+             * @default ['experimental']
+             */
+            includePhases: z.array(z.enum(INTENT_PHASE_VALUES)).default([...INTENT_DEFAULT_PHASES]),
+            /**
+             * Default maximum number of alternatives.
+             * @default 5
+             */
+            maxAlternatives: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .default(5),
+        }).default({
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+            maxAlternatives: 5,
+        }),
         migrationInfo: z.object({
             /**
              * Default Synergy package when none is provided by the caller.
@@ -159,6 +267,20 @@ export const McpRuntimeConfigSchema = z.object({
         componentInfo: { framework: 'vanilla', layer: 'full' },
         davinciMigrationInfo: { package: 'basic-elements' },
         davinciMigrationList: { package: 'basic-elements' },
+        intentCategoriesList: { includePhases: [...INTENT_DEFAULT_PHASES] },
+        intentComponentGuide: { framework: INTENT_DEFAULT_FRAMEWORK, includePhases: [...INTENT_DEFAULT_PHASES] },
+        intentComponentValidate: { framework: INTENT_DEFAULT_FRAMEWORK, includePhases: [...INTENT_DEFAULT_PHASES] },
+        intentOptions: {
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includeDiagnostics: false,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+            maxAlternatives: 5,
+        },
+        intentTaskRecommendations: {
+            framework: INTENT_DEFAULT_FRAMEWORK,
+            includePhases: [...INTENT_DEFAULT_PHASES],
+            maxAlternatives: 5,
+        },
         migrationInfo: { synergyPackage: 'components' },
         migrationList: { synergyPackage: 'components' },
         setup: { includeLimitations: true },