F&O Studio AI Companion

A Visual Studio extension (VSIX) + MCP server that gives GitHub Copilot full D365FO X++ awareness — language knowledge, project context, and 25 metadata tools that create, read, update, validate, search, and manage X++ objects through the official MetaModel API. It is the Visual Studio sibling of F&O Studio for VS Code and shares its AI tools.

Requirements

Problem Statement

GitHub Copilot has no built-in knowledge of X++. When a D365FO developer uses Copilot in Visual Studio, it:

• Does not understand X++ syntax, data types, or keywords (ttsbegin, next, select forupdate, etc.)
• Has no concept of the five D365FO extensibility mechanisms (metadata extensions, CoC, events, extension methods, plug-in/factory)
• Does not know that Microsoft standard objects are read-only and must be extended, never modified directly
• Has no awareness of model descriptors, package dependencies, or ownership rules that determine whether to extend or modify directly
• Cannot reason about where to place new objects or which model/package they belong in
• Has no awareness of the active project's model, metadata structure, or naming conventions
• Cannot create, modify, or inspect D365FO metadata objects programmatically

The result is that Copilot generates invalid or dangerous code — modifying base objects, missing next calls in CoC, using C# syntax instead of X++, or failing to check model dependencies.

Solution

This extension solves the problem at three levels:

1. MCP Server with 25 Metadata Tools

A standalone MCP (Model Context Protocol) server (XppMcpServer.exe) exposes 25 tools that Copilot can call directly. These tools use the D365FO MetaModel API — the same API that Visual Studio uses internally — to manipulate metadata with full type safety.

Supported Object Types (19)

All 19 base types are created via the typed MetaModel API:

All 19 types support read → create → validate → compare.

Object Extensions

IMetaModelService can only read extensions, so extension writes go through the D365FO metadata provider (IMetaModelProviders.CurrentMetadataProvider). Extensions are named <BaseObject>.<Suffix> and can only be created in custom models.

Form extensions are survey-first: xpp_get_form_layout shows the base form with all existing extensions merged (each extension control and data source is attributed) and the child structure each container's pattern expects. New controls must name a parent and a position; placement is validated against that merged form before anything is saved, and re-verified after saving. New controls get the property values their form pattern requires, and the compiler's own form-extension validators run after saving: any error the change would add to the build restores the previous version and is returned with the build's text.

Strongly-Typed JSON Metadata

All create/update/read operations use strongly-typed JSON parameters instead of raw XML. This ensures reliable round-trip metadata fidelity:

• properties — Key-value pairs for scalar metadata (Label, IsExtensible, TableGroup, etc.) with automatic type coercion (string → bool/int/long/enum)
• enumValues — [{ "name": "None", "value": 0, "label": "None" }, ...]
• fields — [{ "name": "CustId", "fieldType": "String", "extendedDataType": "CustAccount", "label": "Customer" }, ...]
• indexes — [{ "name": "CustIdx", "allowDuplicates": false, "fields": ["CustId"] }, ...]
• fieldGroups — [{ "name": "AutoReport", "label": "Report", "fields": ["CustId", "Name"] }, ...]
• relations — [{ "name": "CustTableRel", "relatedTable": "CustTable", "constraints": [{ "field": "CustId", "relatedField": "AccountNum" }] }, ...]
• entryPoints — [{ "name": "Maintain", "objectType": "MenuItemDisplay", "objectName": "CustTable" }, ...]

Read results return the same JSON format, so Copilot can use a read result directly as a template for creating or modifying objects.

Other behaviour worth knowing:

• EDTs: set properties.EdtType (String, Int, Int64, Real, Enum, Date, UtcDateTime, Time, Guid, Container) or properties.Extends; the read shows the kind.
• Label files: xpp_create_object with AxLabelFile and properties.Languages (e.g. en-US,fr-CA) creates one label file per language; xpp_create_label accepts translations and a labels array.
• typedMetadata: items of polymorphic collections take "$type" (as xpp_read_object writes them); unknown keys are refused, so nothing is dropped silently. Query data sources default to dynamicFields true and accept fields.
• Menu extensions: AxMenuExtension with menuElements (menu item, type, parent submenu, position).
• methods: plain X++ source strings, or objects with source.
• Reads: data entities include data sources, entity fields and the staging table; methodNames returns only the requested methods; only non-default properties are shown.
• Validation compares only the attributes you passed, treats Yes/True and No/False alike, and checks project membership for objects of the project's model.
• Find/list reject unknown types, find data entities and security roles, and say 0 matches when nothing matches; xpp_list_model_objects explains package names that contain several models.
• Where-used marks objects from packages that are not installed locally (typically test packages).

2. Embedded X++ Knowledge (System Prompt Injection)

A comprehensive X++ language reference and decision-making framework is compiled into the VSIX assembly as an embedded resource. It covers:

• Ownership-first decision logic: Determines whether to modify directly or extend, based on model descriptors and package ownership
• Model & package awareness: Model descriptor format, ModuleReferences, ModelModule, dependency rules
• Five extensibility mechanisms with decision trees:
  1. Metadata extensions (table/form/enum/EDT extensions — add fields, controls, relations)
  2. Chain of Command (CoC) — wrapping existing methods (class, table, form, data source, data field, control, data entity)
  3. Events & event handlers — table data events, form control/data source/data field events, delegate subscriptions, EventHandlerResult patterns
  4. Extension methods — adding new methods to existing types via _Extension suffix classes
  5. Plug-in / factory — SysExtension and SysPlugin frameworks for strategy pattern variants
• X++ syntax: Data types, classes, method modifiers, data access (select, while select, set-based operations, Query framework)
• Display & edit methods: On tables, as extension methods on standard tables, form-level
• Object type properties: Semantic descriptions of all object types with their valid property values
• Transaction control, exception handling, config key guards
• Naming conventions and best practices

This prompt is injected into every Copilot interaction — both in the context payload and the AI service system message. It travels with the VSIX binary, so it works in any D365FO project regardless of the repository.

3. Dynamic Project Context Pipeline

The extension crawls the open solution's metadata files in real time, scores them by relevance to the developer's current task, and feeds a token-budgeted selection into Copilot's context. This gives Copilot awareness of:

• What objects exist in the current project
• The active document's content
• Related classes, tables, EDTs, and enums
• Whether objects are custom (editable) or Microsoft reference (extend only)

Architecture

For detailed architecture diagrams, design decisions, data flow, reliability mechanisms, and file structure see ARCHITECTURE.md.

Installation

Prerequisites

See Requirements. Building from source also needs the Visual Studio extension development workload.

Install from the Marketplace

In Visual Studio: Extensions > Manage Extensions, search for F&O Studio AI Companion, install, and restart Visual Studio.

Build from Source

1. Clone this repository
2. Open DynDevTools.sln in Visual Studio 2022 or later (or run vsix-companion\build.cmd Release; it finds MSBuild with vswhere)
3. Ensure the Visual Studio extension development workload is installed
4. Build the solution (Ctrl+Shift+B)
5. The VSIX will be in vsix-companion/bin/Release/XppAiCopilotCompanion.vsix
6. The MCP server will be in vsix-companion/mcp-server/bin/Release/XppMcpServer.exe

Install the VSIX

1. Close all Visual Studio instances
2. Double-click XppAiCopilotCompanion.vsix
3. Follow the installer prompts
4. Restart Visual Studio

Upgrading: On the first VS startup after installing a new version, the extension automatically detects the version mismatch, kills the old MCP server, cleans the companion folder, and starts fresh. No manual cleanup needed.

Deploy to a D365FO Dev VM

Copy the .vsix file to the dev VM and double-click to install. The extension activates automatically when a solution is opened. The MCP server starts and stops automatically.

Usage

Configure

Go to Tools > Options > X++ AI Copilot > General and set the Environment Type to match your D365FO environment:

For UDE, metadata paths are auto-detected from the active D365FO VS configuration:

1. Registry — HKCU\Software\Microsoft\Dynamics\AX7\Development\Configurations → CurrentMetadataConfig
2. JSON config file — %LOCALAPPDATA%\Microsoft\Dynamics365\XPPConfig → ModelStoreFolder / ReferencePackagesPaths

For Onebox / CHE, the default PackagesLocalDirectory paths are used automatically. Override them in the Packages Local Directory field if your installation uses a non-standard path.

The Metadata Roots fields (Custom and Reference) can be used for fully custom path overrides on any environment type. Leave them empty to use the environment-driven auto-detection.

MCP Server Registration

The MCP server is registered automatically when the VSIX loads. You can also use:

• Tools > X++ AI: Register MCP Server — Manually register/restart the MCP server
• Tools > X++ AI: MCP Diagnostics — Check MCP server health and tool availability

Using with Copilot Chat

Once the MCP server is registered, Copilot Chat in Visual Studio can call the 16 xpp_* tools directly. Examples:

• "Create an AxEnum called MyStatus with values None, Active, and Closed"
• "Read the CustTable and show me its fields and indexes"
• "Add a String field called MyCustomField to my table"
• "Find all classes that start with 'Cust'"
• "What models are installed?"

Copilot uses the same MetaModel API that Visual Studio uses, so objects are properly registered, cross-referenced, and added to the active project.

Menu Commands

All commands are under Tools in the main menu:

Configuration Reference

Environment

Metadata Roots

Context Budget

Selection

Limitations

• VS Copilot MCP discovery: Visual Studio's Copilot Chat does not always discover or use the registered MCP endpoint automatically. When this happens, you can guide Copilot by explicitly referencing the tools in your prompt (e.g. "use xpp_read_object to read CustTable") or by invoking tools via a PowerShell HTTP call to http://127.0.0.1:21329/ to verify the server is responsive and then retrying in Copilot Chat. This is a known VS Copilot MCP integration limitation.
• VS Copilot language model API: Currently preview/internal in VS 2022. The extension falls back to prompt composition until the API stabilizes.
• No label support for extension types: Label files can be read/created for base types, but not yet for extensions.
• Single model scope: Context pipeline doesn't yet distinguish between multiple models in a multi-model solution.
• AccessGrant on security entry points: The grant field on entryPoints is not yet fully supported — EntryPointType and ObjectName are set, but granular access grants (Read, Update, Delete, Invoke) require a future enhancement.
• UDE config auto-detection depends on D365FO extension: The registry key and JSON config are written by Microsoft's D365FO VS extension. If that extension is not installed or not yet configured, set Environment Type to Onebox or CHE (or set Metadata Roots manually).