New desc
"} or {"System.State":"Active","Custom.MyField":"value"}. Use HTML for Description/ReproSteps. Sta… - `project` (string|null): Optional: Azure DevOps project name. - `workItemId` (integer, required): Work item ID to update. ### `find_references` (~192 tokens) Full index scan for all usages of an object, method, field, or label ID. Use for impact analysis before changing or deleting an object. EXPENSIVE — O(1M+ chunks). Prefer find_callers when XRef index is loaded (O(1)). Label IDs: automatically searches both `@SYS124480` and `@SYS:124480` forms. NOT for extensions only — use find_extensions for CoC/event handlers. Input parameters: - `locationsPerObject` (integer): Maximum number of call sites (methods/fields) to display per referencing object (default: 6, max: 20). Increase to see more usage locations. - `maxResults` (integer): Maximum referencing objects to return (default: 500, max: 2000) - `name` (string, required): The object or method name to find references to, e.g. 'SalesTable', 'validateWrite' ### `ado_gap_fit_analysis` (~419 tokens) WHEN: user asks whether a D365 requirement is standard, needs config, needs an extension, or is a full gap. Also triggered by gap analysis or fit/gap classification of a Work Item. GAP / FIT CLASSIFIER -- Analyse a D365 F&O requirement (from an ADO Work Item OR plain text) and classify it as one of four verdicts: [OK] Standard Fit -- D365 covers this out-of-the-box, no dev needed [gear] Config Fit -- D365 has it but requires parameter / profile setup Extension Fit -- Standard process exists; a CoC/event-handler is enough [X] Gap -- No standard coverage; custom development required For each requirement block the tool returns: \-- Detected D365 domain (Settlement, PaymentJournal, DataImport, ...) \-- Standard objects found in KB and their process step \-- Existing extensions in the custom model (if D365_CUSTOM_MODEL_PATH is set) \-- Effort estimate (hours) and a one-paragraph reasoning Triggers: 'analyse the requirement', 'is this a gap or fit', 'gap analysis WI #N', 'standard or custom for WI #N', 'does D365 cover this'. [~] When a WI has already been analysed by `ado_analyze_workitem` in the same turn, pass the requirement text directly via `requirementText` -- do NOT re-fetch with `workItemId`. Input parameters: - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `requirementText` (string|null): Optional: raw requirement text to analyse directly (when no WI ID is provided). - `requirements` (string|null): Optional: comma-separated list of requirement sentences to analyse individually (overrides WI + requirementText). - `workItemId` (integer|null): Optional: Work Item ID to fetch the requirement from ADO (e.g. 6587). Leave empty to use requirementText. ### `batch_search` (~232 tokens) WHEN: you need context on multiple D365 objects or concepts simultaneously -- runs all queries in parallel. Use INSTEAD of multiple sequential search_d365_code calls -- each line becomes one parallel search. Maximum 6 queries per call. Results are equivalent to search_d365_code but returned together. When batch_search returns results, all matching objects are FULLY loaded (all chunks). Do NOT follow up with get_object_details on the same objects -- the complete source is already included. Triggers: 'find all of these', 'look up multiple', 'cherche plusieurs', 'SalesTable AND VendTable', 'several objects at once', 'lookup X and Y and Z', 'plusieurs objets en même temps', 'context on all of these'. Input parameters: - `queries` (string, required): Newline-separated search queries (max 6). Example: "SalesTable\nVendTable\nvendor invoice posting" - `topK` (integer): Results per query (default: 5, max: 15) - `topObjects` (integer): Full-chunk objects per query (default: 3, max: 8) ### `ado_read_attachment` (~394 tokens) AZURE DEVOPS ONLY -- Reads the ACTUAL CONTENT of a file attached to a work item (Excel spreadsheet, Word document, text/CSV/JSON/XML file, or image). WHEN: a work item (FDD/RDD/CR/Bug/Task/User Story) has an Excel/Word attachment with requirements, field mappings, mockups, or specs that need to be read to understand the ask. Triggers: 'read the attachment', 'open the excel file on the work item', 'what does the attached document say', 'lis le fichier joint', 'ouvre l'excel du ticket'. Call ado_analyze_workitem first (or ado_query_workitems) to discover attachment file names if you don't already know the exact fileName. Supported: .xlsx/.xlsm (returns sheet names + a markdown table of the requested/first sheet), .docx (returns extracted markdown text + tables), .txt/.csv/.json/.xml/.md/.log (returned as-is), images (.png/.jpg/.jpeg/.gif/.bmp/.webp, returned as a base64 data URI for visual analysis, max 4 MB). Other binary formats (PDF, .pptx, .zip, etc.) are NOT parsed -- returns metadata + a manual download link instead. Max attachment size read: 25 MB. Requires DEVOPS_ORG_URL + DEVOPS_PAT env vars. Input parameters: - `fileName` (string, required): Exact attachment file name as shown by ado_analyze_workitem, e.g. 'Field Mapping.xlsx'. Case-insensitive. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `sheetName` (string|null): Optional: sheet name for .xlsx/.xlsm attachments. Defaults to the first sheet. - `workItemId` (integer, required): Work item ID, e.g. 1234 ### `trace_field_lineage` (~195 tokens) WHEN: you need to understand the full data lifecycle of a D365 F&O table field: who writes it, who reads it, which forms display it, which reports use it, and which tables have FK relationships to its parent table. Triggers: 'where is field X set', 'qui écrit ce champ', 'data lineage', 'GDPR field audit', 'origin of field', 'what touches this field'. Requires XRef index for writer/reader analysis. Relation graph for forms and FKs. Examples: trace_field_lineage('CustTable','CreditMax') or trace_field_lineage('LedgerJournalTrans','AmountCurDebit'). Input parameters: - `fieldName` (string, required): Field or property name, e.g. 'CreditMax'. - `maxPerCategory` (integer): Max results per category (default 15). - `tableName` (string, required): Table or class name, e.g. 'CustTable'. ### `plan_and_execute` (~396 tokens) CHAIN-OF-TOOLS PLANNER -- Execute a multi-step JSON plan in ONE call by chaining tools. Pass an EXPLICIT JSON array of steps (NL parsing disabled to prevent ambiguity). Maximum 5 steps per plan. The chain stops on any critical failure (ado_analyze_workitem, get_object_details). \## Required Format (JSON array) \`[{"tool":"get_object_details","args":{"objectName":"SalesTable"}},{"tool":"validate_best_practices","args":{"objectName":"SalesTable"}}]` \## When to use \- You already know the exact sequence of 2-5 tool calls needed \- The output of step N is independent of step N+1 (or matches the carried context: analysis_output) \- You want SSE progress events between steps \## When NOT to use \- Single tool call (use the tool directly) \- Plan depends on the user's intermediate decision (call tools one at a time) \- More than 5 steps (split into separate calls) \## Cost: $0 -- pure in-process execution. Input parameters: - `assignTo` (string|null): Optional: assignee email for task creation step, e.g. 'dev@company.com'. - `description` (string|null): Optional: additional description text to pass to task creation step. - `goal` (string, required): Natural language goal OR a JSON array of explicit steps. Examples: 'analyse WI #6587 and create a task', 'check best practices for ALMMyClass'. - `objectName` (string|null): Optional: object name to use when goal references a D365 object (overrides name parsed from goal). - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `workItemId` (integer|null): Optional: work item ID to use when goal references 'WI #N' (overrides ID parsed from goal text). ### `find_similar_implementations` (~142 tokens) Find D365 objects structurally similar to the one you supply (same kind, similar method set, similar field set). Useful when you need a working reference implementation to copy from. Input parameters: - `filterAotType` (string|null): Optional: filter to a specific AOT type, e.g. 'AxTable', 'AxClass'. If not set, uses the same type as the source object. - `maxResults` (integer): Maximum results (default: 15, max: 30) - `objectName` (string, required): Object name to find similar objects for, e.g. 'ALMERSftpConnectionTable', 'SalesTable' ### `recommend_extension_strategy` (~195 tokens) WHEN: developer about to customise a standard D365 object asks 'should I use AxTableExtension, Chain of Command, EventHandler, or Delegate?'. Triggers: 'how to extend', 'best way to customise', 'extension strategy for', 'CoC ou event handler', 'comment etendre X'. Returns a ranked recommendation based on the target AOT type and the intent, with citations to the Microsoft Learn extensibility guide. Cloud-safe: pure KB lookup, no writes. Input parameters: - `intent` (string, required): Plain-language goal of the customisation. Examples: 'add a status field', 'change validateWrite logic', 'react to record insert', 'replace the posting logic', 'override the find method', 'extend the… - `objectName` (string, required): Target standard D365 object name, e.g. 'SalesTable', 'CustTable', 'SalesLineType', 'PurchFormLetter_Confirmation'. ### `diff_model_versions` (~180 tokens) Compare two D365 F&O KB snapshots to produce a changelog (added/removed/modified objects). Use action 'save_baseline' once, then 'compare' between two snapshots. Input parameters: - `action` (string, required): Action: 'compare' (current vs baseline), 'compare_caches' (two cache files), or 'save_baseline' (save current state) - `filterModel` (string|null): Optional: filter to a specific model name - `path1` (string, required): For 'compare': path to baseline cache file. For 'compare_caches': path to first cache. For 'save_baseline': output path for the baseline file. - `path2OrLabel` (string|null): Optional: For 'compare_caches': path to second cache file. For 'compare'/'save_baseline': label for the baseline. ### `find_related_objects` (~97 tokens) Returns ALL FK/DeleteAction/DataSource relations (outgoing) AND back-references (incoming). Call BEFORE generating multi-object code to understand the full dependency graph. When the relation index is loaded, delegates to get_relation_graph (O(1)) internally — do NOT call both tools for the same object. Input parameters: - `objectName` (string, required): The object name to find relationships for, e.g. 'SalesTable', 'VendInvoiceJour' ### `ado_review_xpp_pr` (~229 tokens) WHEN: reviewing a PR that modifies X++ code or AOT objects and you need D365-specific insights. Returns a structured code review for each changed object: blast radius (who calls it), existing best-practice violations, performance issues, and impact severity. Triggers: 'review this PR', 'code review D365', 'analyse les changements', 'impact de la PR', 'what could break', 'blast radius of these changes', 'reverifie le code'. Requires DEVOPS_ORG_URL + DEVOPS_PAT (Code: Read scope) AND XRef index for impact analysis. Combine with ado_post_pr_comment to post findings as inline review comments. Input parameters: - `maxDeepAnalysis` (integer): Max AOT objects to deeply analyse (1-20, default 8). Objects beyond this limit are listed but not deeply analysed. - `prId` (integer, required): Pull Request ID to review. - `project` (string|null): Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `repositoryId` (string|null): Git repository name or ID. ### `dmf_create_data_project` (~236 tokens) Create (or extend) a DMF data project -- EXPORT or IMPORT -- entirely through standard public OData entities, with NO X++ customization required. It POSTs the header to DataManagementDefinitionGroups and one row per entity to DataManagementDefinitionGroupDetails with AutoGenerateMapping=Yes, so FO generates each entity's source<->staging mapping automatically. Idempotent: an existing project is reused and entities already present are skipped. For EXPORT, the project can then be run with dmf_export_package. Provide an EXISTING DMF 'source data format' name for sourceName (e.g. a comma-delimited format). Input parameters: - `entities` (string, required): Comma-separated DMF entity names, e.g. 'Customers V3,Released products V2'. - `operationType` (string): Operation type: 'Export' (default) or 'Import'. - `projectName` (string, required): Name of the data project (definitionGroupId) to create or extend. - `sourceName` (string, required): Existing DMF source data format name that defines the file format. ### `find_entity_for_table` (~285 tokens) WHEN: developer needs to integrate via OData and wants to find the entity name for a given table. Also generates a new entity template when none exists and generateIfMissing=true. Triggers: 'which entity exposes', 'OData entity for', 'find entity for', 'quelle entité expose', 'DMF entity for', 'create data entity', 'expose via OData', 'generate entity', 'entité de données'. Find D365 F&O data entities that expose a given table for OData/DMF integrations. Answers: 'Which entity exposes SalesTable for OData?' Scans all indexed AxDataEntityView objects to find entities with matching data sources. Returns entity name, public entity name (for OData URL), IsPublic status, key fields, and all data sources. Essential for integration development. Set generateIfMissing=true to auto-generate an AxDataEntityView XML template when no public entity is found. Input parameters: - `generateIfMissing` (boolean): When true and no public entity is found, generates a new AxDataEntityView XML template for the table. Default: false. - `maxResults` (integer): Maximum results (default: 15, max: 30) - `tableName` (string, required): Table name to find entities for, e.g. 'SalesTable', 'CustTable', 'VendInvoiceJour' ### `summarize_for_stakeholder` (~151 tokens) WHEN: you have a large technical tool output (get_object_details, validate_best_practices, ado_analyze_workitem, detect_performance_issues...) and need it reframed for a non-technical audience. Calls the local Ollama instance (OLLAMA_HOST env var, default localhost:11434) to produce the summary. Model is configurable via ALMXPP_SUMMARIZE_MODEL (default: llama3.2). Input parameters: - `audience` (string): Target audience: 'executive', 'business-analyst', or 'developer'. Default 'business-analyst'. - `text` (string, required): The technical text to summarize/explain -- typically the raw output of another tool call. ### `suggest_refactoring` (~203 tokens) WHEN: developer wants to improve code quality before a PR merge or code review. Triggers: 'refactor', 'clean up', 'simplify', 'too long method', 'nested ifs', 'code smells', 'améliorer le code'. Suggest concrete refactoring actions for YOUR custom D365 F&O X++ code. [!] Only runs on custom/extension code (D365_CUSTOM_MODEL_PATH). Refactoring standard Microsoft code is not actionable. Analyzes: long methods (extract method), deep nesting (guard clauses), row-by-row operations (set-based), large switch statements (strategy pattern), hardcoded strings (constants), unprotected CLR calls (error handling), wide transactions (narrow scope). Returns before/after code examples. Input parameters: - `methodName` (string|null): Optional: specific method to analyze. - `objectName` (string, required): Object name to analyze, e.g. 'ALMMyClass', 'ALMMyTable' ### `resync_devops_index` (~230 tokens) WHEN: the user wants to force a full re-download and re-index of their Azure DevOps custom model. Triggers: 'resync', 'reindex', 'force sync', 'rebuild index', 'my model is stale', 'update index', 'mon index est vieux', 'rafraîchir l\'index', 'relancer l\'indexation'. Useful when the server's built-in PAT does not have access to the target DevOps organisation (e.g. a different Azure DevOps org or tenant). Pass a `pat` parameter to override the server PAT for this resync. The eviction + download runs in the background; returns status immediately. After calling, wait ~60 s then call `healthcheck` or any search tool to confirm the index is ready. Input parameters: - `pat` (string|null): Optional: Personal Access Token with Code (Read) permission for the target Azure DevOps org. Provide this when the server's built-in PAT lacks access (e.g. a different tenant, cross-org). Leave blank… ### `ado_wiki_get_page` (~165 tokens) AZURE DEVOPS ONLY -- Read the content of a wiki page (and its immediate sub-page paths). path uses wiki page-path syntax, e.g. '/Home' or '/Architecture/Deployment'. Requires DEVOPS_ORG_URL + DEVOPS_PAT env vars. Input parameters: - `includeSubPages` (boolean): Also list immediate sub-page paths under this page. - `path` (string, required): Wiki page path, e.g. '/Home' or '/Architecture/Deployment'. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `wikiIdentifier` (string|null): Wiki name or id. Omit to auto-resolve to the project's only/first wiki (call ado_wiki_list if there are several). ### `dmf` (~642 tokens) Consolidated Data Management Framework tool — one entry point for all 5 DMF operations, selected via `action`. Each action forwards to the exact same implementation as its dedicated tool (dmf_import_file / dmf_create_data_project / dmf_apply_entity_filter / dmf_export_package / dmf_get_job_status) — identical behavior and validation, just one tool schema instead of five. The dedicated tools remain available unchanged. action="import" (= dmf_import_file): entityName, legalEntity, filePath OR csvContent, definitionGroupId?, execute?, overwrite?, pollTimeoutSeconds? action="create_project" (= dmf_create_data_project): projectName, entities, sourceName, operationType? ('Export' default or 'Import') action="apply_filter" (= dmf_apply_entity_filter): projectName, entityRowName, aotEntityName, fieldName, filterValue action="export" (= dmf_export_package): definitionGroupId, legalEntity, packageName?, reExecute?, pollTimeoutSeconds? action="status" (= dmf_get_job_status): executionId Input parameters: - `action` (string, required): import | create_project | apply_filter | export | status - `aotEntityName` (string|null): apply_filter: AOT entity name, e.g. 'VendVendorV2Entity'. - `csvContent` (string|null): import: inline CSV content (or use filePath). - `definitionGroupId` (string|null): import/export: definitionGroupId (DMF project id). - `entities` (string|null): create_project: comma-separated DMF entity names. - `entityName` (string|null): import: target DMF entity name, e.g. 'Customers V3'. - `entityRowName` (string|null): apply_filter: entity row label, e.g. 'Vendors V2'. - `execute` (boolean): import: execute after staging. Default true. - `executionId` (string|null): status: the executionId returned by an import or export action. - `fieldName` (string|null): apply_filter: field to filter on, e.g. 'VendorAccountNumber'. - `filePath` (string|null): import: path to a .csv file on disk (or use csvContent). - `filterValue` (string|null): apply_filter: value or wildcard to match. - `legalEntity` (string|null): import/export: legal entity / company id, e.g. 'USMF'. - `operationType` (string|null): create_project: 'Export' (default) or 'Import'. - `overwrite` (boolean): import: overwrite existing project definition. Default true. - `packageName` (string|null): export: optional package name. - `pollTimeoutSeconds` (integer): import/export: max seconds to poll for completion. Default 300. - `projectName` (string|null): create_project/apply_filter: DMF project name. - `reExecute` (boolean): export: re-execute the project. Default true. - `sourceName` (string|null): create_project: existing DMF source data format name. ### `find_callers` (~182 tokens) Full cross-reference profile for a class or method: callers, callees, inheritance chain, interface implementations, overrides, attributes. Requires xref_index.json.gz (generated from DYNAMICSXREFDB via GenerateCache --xref-conn). Falls back to vector-search when XRef not loaded. Input parameters: - `categories` (string): Categories to include: 'all' (default), or comma-separated subset: 'calls,inheritance,usage,interfaces,overrides,attributes' - `depth` (integer): Depth of caller chain to trace upward (default: 2, max: 4) - `maxResults` (integer): Maximum results per category (default: 20, max: 50) - `methodKey` (string, required): Object or method key. Format: 'ClassName.methodName' for methods, 'ClassName' for class-level queries. ### `healthcheck` (~66 tokens) WHEN: checking server status, loaded D365 version, or custom model path. Triggers: 'status', 'statut', 'is the server ready', 'how many chunks', 'index loaded'. Returns JSON with: status, indexed chunk count, loaded version, custom model path. ### `ado_analyze_pr_impact` (~625 tokens) [~] PRIORITY TRIGGER: Use this tool when the user says 'analyse PR', 'review PR', 'check PR', 'PR #', 'impact du PR', 'analyse la PR', 'what changed in PR', 'D365 impact of PR', 'code review PR', 'violations in PR', 'PR review'. NEVER call search_d365_code when 'PR' or 'Pull Request' + a number is mentioned. Analyse the full D365 F&O code impact of a Pull Request. Reads each changed file's CONTENT straight from the PR's source commit via the ADO REST API, so it reviews the PROPOSED (un-merged) code -- including brand-new files that do not yet exist on the target branch. DO NOT fall back to local `git show`/`git diff`: this tool already pulls the un-merged content over the API and analyses it against the indexed standard KB. When `includeSource` is true (the default), the FULL un-merged source of every analysed file is embedded in the output (one fenced block per file), so you have everything needed for a complete semantic review -- BP findings AND the actual code -- in a single call. NEVER run git to read the files. This matters for metadata-only PRs (tables/enums/menu items/reports): the BP engine is X++-centric and may report few violations on AOT XML, but the embedded source lets you review those changes properly. For every X++ class/table/form/extension modified in the PR: (1) Best Practice validation -- reports Critical and Warning violations. (2) Upgrade impact -- cross-references CoC targets, event handlers, and extensions against the D365 standard code. (3) Extension conflicts -- finds existing CoC/extensions that may conflict. (4) Produces a ready-to-post PR review comment addressed to the PR author. After reviewing, call `ado_post_pr_comment` to post the review (requires user confirmation). Requires DEVOPS_ORG_URL + DEVOPS_PAT (Code: Read). Input parameters: - `includeSource` (boolean): Embed the un-merged SOURCE of each analysed file in the output so the reviewer can do a full semantic code review without a local git checkout. Default true. - `includeWarnings` (boolean): Include Warning-level violations in addition to Critical (default: true). Set false for Critical-only. - `maxFilesDeep` (integer): Max X++ files to fully analyse (default 10, max 20). Larger PRs get a summary for remaining files. - `prId` (integer, required): Pull Request ID (integer), e.g. 42. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `repositoryId` (string, required): Git repository name or ID. - `sourceCharsPerFile` (integer): Max characters of source to embed per file when includeSource is true (1000-40000, default 8000). Larger files are truncated with a note. ### `find_error_patterns` (~364 tokens) WHEN: a user encounters an error message, infolog error, or runtime exception in D365. Also handles business-language error explanation when audienceType='business'. Triggers (developer): 'fix this error', 'what causes', 'exception thrown', 'infolog error', 'update conflict', 'outside tts', 'number sequence'. Triggers (business): 'what does this error mean', 'explain this error to me', 'user gets error X', 'que signifie cette erreur', 'message d\'erreur', 'what should the user do when they see this error'. Find known D365 F&O error patterns matching an error message or symptoms description. Matches against a built-in database of common errors (transaction conflicts, security issues, number sequences, posting errors, batch problems, etc.), resolves D365 label IDs from error text (e.g. user sees 'Number sequence not set up' -> finds @SYS70535 -> finds the throwing code), and searches the indexed codebase. Returns root causes, step-by-step resolution, label matches, and source code locations. [~] When the error text contains a D365 label ID (e.g. '@SYS12345'), call `search_labels` first to resolve the label text, then call this tool with the resolved text. Set audienceType='business' for a plain-language explanation targeted at end users instead of developers. Input parameters: - `audienceType` (string): Audience type: 'developer' (default) for root-cause analysis, or 'business' for a plain-language explanation targeted at end users. - `errorOrSymptom` (string, required): Error message text or symptom description, e.g. 'update conflict', 'number sequence not set up', 'cannot create record outside tts' ### `suggest_edt` (~247 tokens) WHEN: adding a new field to a table -- find the best existing D365 EDT to extend instead of using raw primitives (str, int64, real, date). Triggers: 'what EDT for', 'which EDT should I extend', 'quel EDT pour', 'quel type étendu', 'EDT for a field'. D365 best practice mandates EDT reuse over raw primitive types. Call BEFORE declaring any field with a primitive type. Returns ranked candidate EDTs with their base type, label, and model. Input parameters: - `baseType` (string|null): Optional: D365 primitive base type to filter by, e.g. 'str', 'int64', 'real', 'date', 'enum'. Leave empty to search all types. - `fieldName` (string, required): Field name or concept, e.g. 'AccountNum', 'vendorId', 'itemCode', 'approvalStatus' - `purpose` (string, required): Purpose of the field in plain language, e.g. 'customer account number', 'approval status enum', 'invoice amount in transaction currency' - `topK` (integer): Number of EDT candidates to return (default: 8, max: 20) ### `get_object_context` (~228 tokens) WHEN: you need a COMPLETE picture of a D365 object in ONE call. Returns in a single response: full structure (fields, method signatures, relation summary) AND all CoC extensions / event handlers -- equivalent to calling get_object_details THEN find_extensions. Use this INSTEAD of those two separate calls to reduce round-trips. Optionally includes best-practice violations (set includeValidation=true). Pass `methodName` to also include the full body of a specific method. Pass `aotType` to disambiguate when several AOT objects share the same name. Input parameters: - `aotType` (string|null): Optional: AOT type to disambiguate, e.g. 'AxTable', 'AxClass', 'AxForm'. - `includeValidation` (boolean): Include best-practice violations (default false -- adds latency for large objects). - `methodName` (string|null): Optional: specific method name to include full body for. - `objectName` (string, required): Exact object name, e.g. 'SalesTable', 'CustTable', 'VendInvoiceJour' ### `odata_upsert_rows` (~231 tokens) Idempotent import of rows into any entity via OData: PATCH when the record exists (matched by keyFields), otherwise POST. Safe to re-run -- duplicates are updated, not re-created. Best for small-to-medium transactional loads (e.g. <= a few thousand rows). For bulk loads use dmf_import_file. Provide rows as a JSON array of objects; resolve key fields from the KB (get_data_entity_info) -- do not guess them. Input parameters: - `crossCompany` (boolean): Set true to allow cross-company writes. - `entitySet` (string, required): OData public entity set name, e.g. 'CustomersV3'. - `keyFields` (string, required): Comma-separated business key fields used to detect existing records, e.g. 'CustomerAccount' or 'dataAreaId,ItemNumber'. - `legalEntity` (string|null): Optional legal entity (dataAreaId) injected into each row when absent. - `rowsJson` (string, required): JSON array of row objects, e.g. [{"CustomerAccount":"C0001","Name":"Acme"}]. ### `find_change_impact` (~225 tokens) WHEN: about to modify an X++ object or method and need to understand what could break. Returns a blast-radius report: direct callers, transitive dependents (BFS up to 3 hops), custom model extensions, interface propagation, and severity classification (Critical/High/Medium/Low). Requires the XRef index (loaded from xref_index.json.gz). Triggers: 'what breaks if I change X', 'impact of modifying SalesLine', 'blast radius', 'refactoring risk', 'quel impact si je modifie', 'qu\'est-ce qui dépend de'. Pass objectName='SalesLine' for table/class-level impact, or objectName='SalesLine.insert' for method-level impact. Combine with validate_best_practices / detect_performance_issues to get both impact AND current code quality before committing a change. Input parameters: - `maxDepth` (integer): Max BFS depth (1-5). Default 3. - `objectName` (string, required): Object or method to analyse, e.g. 'SalesLine' or 'SalesLine.insert'. ### `generate_security_report` (~123 tokens) Generate a security & licensing governance report for the indexed model(s). For each role, lists duties, privileges, entry points and the inferred user-license tier (Activity, Operations, Finance, etc.). Surfaces orphan duties/privileges that grant no real access. Input parameters: - `filterModel` (string|null): Optional: restrict the report to a single model name (e.g. 'ApplicationSuite', 'ContosoCustom'). Empty = all indexed models. - `maxRolesDetail` (integer): Maximum number of roles to expand in detail (default 50, max 200). ### `ado_create_task` (~629 tokens) WHEN: user asks to create a DevOps Task or start development on a Work Item. Triggers: 'create task', 'créer une tâche', 'start development on', 'commencer le dev sur', 'créer un task ADO', 'new development task for WI'. Create a D365 F&O development Task work item in Azure DevOps following the project naming convention. Rules applied automatically based on the parent work item: (A) Parent title starts with a project prefix + digits (FDD/RDD/IDD/CR/...) => Task named '{Prefix} - N - {Title}', Task is child of that WI, branch '{Prefix}_Task_{id}'. (B) Selected WI is related to a prefixed WI (e.g. a Bug linked to a CR) => Task is child of the prefixed WI, Bug is 'related' to the Task, same naming. (C) No prefixed relation => Task named '{3-letter-type}{wiId} - N - {Title}', child of selected WI, branch '{3-letter-type}{wiId}_Task_{id}'. The N counter increments automatically based on existing sibling tasks. A Git branch is created automatically in the repository. Assignee and CC list are embedded in the task description. LANGUAGE RULE: write the 'description' (Proposed Solution) in the same language the user used in their request. Default is English. If the user wrote in French, write the solution in French. Static section labels (headers, field names) remain in English. Requires DEVOPS_ORG_URL + DEVOPS_PAT (Work Items: Read & Write, Code: Read & Write). Input parameters: - `areaPath` (string|null): Optional: area path for the new task, e.g. 'MyProject\SER'. Inherits from parent if omitted. - `assignTo` (string|null): Optional: email address of the person to assign the task to, e.g. 'dev@company.com'. - `description` (string|null): Optional: additional description / acceptance criteria text to append to the task. - `effortHours` (integer|null): Optional: estimated effort in hours (Original Estimate). - `iterationPath` (string|null): Optional: iteration path for the new task, e.g. 'MyProject\Sprint 5'. Inherits from parent if omitted. - `notifyList` (string|null): Optional: comma-separated list of email addresses to notify (added to task description), e.g. 'lead@company.com,qa@company.com'. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `repositoryId` (string|null): Optional: Git repository name to create the branch in. If omitted, uses the first repository found. - `sourceBranch` (string|null): Optional: source branch to branch from (default: repo default branch, e.g. 'main'). - `workItemId` (integer, required): ID of the selected Work Item (parent, bug, issue, etc.) to base the task on. ### `appinsights_set_connection` (~381 tokens) Securely register the D365 F&O environment's Application Insights / Log Analytics connection for the CURRENT session. The client secret is encrypted in memory (AES-256-GCM), never written to disk and never echoed back. Once set, appinsights_query and appinsights_diagnose_slowness use it automatically until it expires or you call appinsights_clear_connection. HOW TO GET THE VALUES: workspaceId -- the Log Analytics WORKSPACE ID (GUID, not the App Insights app id) behind the Application Insights resource the environment is linked to (D365FO: System administration > Monitoring and Telemetry parameters > Application Insights Registry tab shows the connection string; the workspace id is on that Log Analytics workspace resource's Overview blade in the Azure Portal). tenantId/clientId/clientSecret -- an Entra ID app registration granted the 'Log Analytics Reader' (or 'Monitoring Reader') role on that workspace resource (Azure Portal > workspace > Access control (IAM) > Add role assignment). Read-only -- no write access is ever needed or used. In a locked server deployment (APPINSIGHTS_LOCK_SERVER_CONFIG=true) this tool is disabled and the server's own environment credentials are used instead. Input parameters: - `clientId` (string, required): App registration (client) id (GUID), granted Log Analytics Reader on the workspace. - `clientSecret` (string, required): App registration client secret. Encrypted in memory; never logged or persisted. - `tenantId` (string, required): Entra (Azure AD) tenant id (GUID). - `ttlMinutes` (integer): Minutes the connection stays cached for this session (1-480). Default 60. - `workspaceId` (string, required): Log Analytics workspace ID (GUID) behind the linked Application Insights resource. ### `dmf_get_job_status` (~78 tokens) Poll the status of a DMF import/export execution by its executionId (e.g. NotRun, Executing, Succeeded, PartiallySucceeded, Failed). For a completed export, also returns the download URL. Input parameters: - `executionId` (string, required): The executionId returned by dmf_import_file or dmf_export_package. ### `detect_performance_issues` (~133 tokens) Profile an X++ object for N+1 queries, queries in loops, missing field lists, row-by-row inserts/updates, missing firstOnly. Returns compact issue table with line + fix. Only call when performance is explicitly the concern — for general quality use validate_best_practices. [!] Auto-fixing requires D365_CUSTOM_MODEL_PATH (custom code only). Input parameters: - `methodName` (string|null): Optional: specific method to analyze. Analyzes all methods if not provided. - `objectName` (string, required): Object name to analyze, e.g. 'SalesTable', 'CustInvoiceJour' ### `get_relation_graph` (~293 tokens) WHEN: you need the COMPLETE bidirectional relation graph for an object in ONE call. Triggers: 'relations of', 'FK of', 'what tables link to', 'quelles tables liées à', 'avant de générer du code', 'before generating code', 'foreign keys', 'delete actions', 'who references', 'qui référence', 'graph de relations'. Returns ALL outgoing edges (FK relations, DeleteActions, DataSources, Extensions, Security...) AND all incoming back-references (forms, entities, CoC classes, privileges... that reference it). Backed by the pre-computed relation index -- O(1) lookup, no vector scan. Much faster and more complete than find_related_objects for known object names. ALWAYS call this before generating code that touches multiple objects or requires join logic. Use find_related_objects when the relation index is not yet built (fallback to vector scan). Input parameters: - `aotTypeFilter` (string|null): Optional: filter edges by relation kind to reduce noise. Comma-separated. Examples: 'TableFK', 'DeleteAction', 'Extension', 'DataSource', 'Security'. Leave empty for all kinds. - `maxEdges` (integer): Maximum edges to show per direction (default: 200, max: 500) - `objectName` (string, required): The exact object name, e.g. 'SalesTable', 'CustTable', 'SalesFormLetter' ### `d365fo_clear_connection` (~30 tokens) Removes the D365 F&O connection cached for the current session by d365fo_set_connection. ### `generate_xpp_template` (~212 tokens) WHEN: writing an extension or customization -- generates ready-to-use X++ code. Triggers: 'génère un CoC', 'crée une extension', 'generate extension', 'write a CoC class', 'event handler pour', 'template pour'. Uses REAL metadata from the KB (actual field names, method signatures). 'coc' = Chain of Command class, 'table_extension' = extend table with fields/methods, 'event_handler' = pre/post event handler, 'job' = runnable class, 'find_method' = find/exist pattern. ALWAYS call get_object_details first to verify the object exists. Input parameters: - `methodName` (string|null): Optional: specific method name for CoC or event handler templates - `objectName` (string, required): The base object, e.g. 'SalesTable', 'VendInvoiceJour' - `templateType` (string, required): Template type: 'coc', 'table_extension', 'event_handler', 'job', 'find_method' ### `get_security_coverage_for_object` (~226 tokens) WHEN: developer/security architect needs to know WHICH ROLES can access a specific form, table, menu item or service operation. Triggers: 'who can access', 'which roles see', 'security coverage for', 'quels roles ont accès à', 'find roles with access'. Walks the security graph backwards (EntryPoint -> Privilege -> Duty -> Role) and returns all roles that grant any level of access (Read / Update / Create / Delete / Correct) on the given object. Read-only: scans the in-memory KB, never writes. Input parameters: - `maxRoles` (integer): Maximum roles to expand (default 30, max 100). - `minGrant` (string): Optional: minimum grant level to include in results. Values: 'Read', 'Update', 'Create', 'Delete', 'Correct', 'Any'. Default: 'Any'. - `objectName` (string, required): Object name to audit (form, table, menu item, service operation). Example: 'CustTable', 'SalesTableListPage', 'CustCustomerServiceMenu'. ### `get_output_page` (~180 tokens) Retrieve the NEXT page of a previously PAGINATED tool output. When a tool result is too large for a single response, it is split losslessly into ordered pages — the footer of each page gives you a `token` and the next `page` number. Call this tool with that token to read the continuation; nothing is dropped, so you can walk every page in order and reconstruct the full result. Pages are cached only briefly (the last few large results). If the token is unknown or expired, re-run the original tool to regenerate it. Input parameters: - `page` (integer): The page number to retrieve (the previous page footer tells you the next one). Defaults to 2. - `token` (string, required): The pagination token from a paginated tool's footer, e.g. 'op_a1b2c3d4e5'. ### `ado_pr_dependency_map` (~339 tokens) PR DEPENDENCY MAP -- Scan multiple Pull Requests and build a cross-PR dependency graph based on (a) shared X++/AOT objects and (b) branch chain relationships. For each PR: \* Lists X++ / AOT objects changed (from diff) \* Detects OBJECT CONFLICTS: same object modified in multiple PRs => merge risk \* Detects BRANCH CHAIN: if PR_A.targetBranch == PR_B.sourceBranch => PR_A must merge first \* Computes RECOMMENDED MERGE ORDER (topological sort by branch dependencies) Output: \* Per-PR object table \* Conflict matrix (object -> [PR list]) \* Dependency graph summary \* Ordered merge sequence Triggers: 'PR dependencies', 'ordre de merge des PR', 'conflits entre PR', 'quelles PR touche le même objet', 'dependency map PRs', 'merge order PRs', 'list PRs with objects', 'objets par PR', 'cross-PR impact'. Requires DEVOPS_ORG_URL + DEVOPS_PAT (Code: Read scope). Input parameters: - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `repositoryId` (string, required): Git repository name or ID. - `status` (string): PR status filter: Active (default), Completed, Abandoned, All. - `targetBranch` (string|null): Optional: filter by target branch, e.g. 'develop'. - `top` (integer): Maximum PRs to analyse (default: 30, max: 60). ### `generate_fdd` (~234 tokens) WHEN: user asks to write or generate a Functional Design Document, FDD, functional spec, CdC, or cahier des charges. NOT for developer technical docs -- use `get_object_details` for that. FUNCTIONAL DESIGN DOCUMENT GENERATOR -- Produces a structured FDD ready for review and sign-off. Sections generated: Purpose, Business Context, Data Fields (with resolved labels), Business Rules, Related Objects, Security, and Open Questions. Triggers: 'write FDD for', 'generate FDD', 'functional spec for', 'document this process', 'write functional design', 'rédiger le cahier des charges', 'CdC pour', 'fiche de conception'. Input parameters: - `context` (string|null): Optional: additional business context, requirements, or audience note to include in the header - `language` (string): Optional: output language ('en', 'fr', 'nl', 'de'). Default: en - `objectName` (string, required): D365 object or business process name, e.g. 'SalesTable', 'VendInvoiceInfoTable', 'ALMDemandeAchat' ### `map_business_process` (~283 tokens) WHEN: mapping the technical D365 objects behind a business process, or understanding which tables/forms implement a flow. Triggers: 'processus métier', 'Order-to-Cash', 'Procure-to-Pay', 'Record-to-Report', 'business process flow', 'qui est impliqué dans', 'map the process', 'flux du processus', 'quels objets dans le flux'. Map a D365 F&O business process to its complete object chain. For known processes (Order-to-Cash, Procure-to-Pay, Record-to-Report, Plan-to-Produce, Inventory-Management, Hire-to-Retire, Project-Accounting, Asset-Lifecycle): shows every step with forms, tables, classes, entities, reports, and security roles involved. For any other object name: traces all dependencies (tables, classes, forms, entities) from that entry point. Produces a Mermaid process flow diagram. Use 'list' to see all known process mappings. NOT for a single object's FK relations only -- use `find_related_objects` for that (faster and more precise). Input parameters: - `processName` (string, required): Business process name (e.g. 'Order-to-Cash', 'Procure-to-Pay', 'sales', 'purchasing') or an object name to trace from. Use 'list' to see all known processes. ### `ado_post_comment` (~218 tokens) WHEN: user explicitly asks to post, add, or save a comment to an ADO Work Item. [~] PRIORITY TRIGGER: call AFTER `ado_analyze_workitem` when user says 'post the analysis', 'save it to the ticket', 'ajoute en commentaire'. WARNING: ALWAYS ask for explicit user confirmation before calling this tool. Recommended workflow: (1) call `ado_analyze_workitem`, (2) show analysis to the user, (3) ask 'Shall I post this comment to Work Item #X?', (4) only then call this tool. Requires DEVOPS_ORG_URL + DEVOPS_PAT with Work Items: Write permission. Input parameters: - `commentText` (string, required): Markdown text to post. Use the ready-to-post block from `ado_analyze_workitem`. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `workItemId` (integer, required): Work item ID (integer), e.g. 1234 ### `get_data_entity_info` (~118 tokens) WHEN: developer building an OData / DMF integration needs a quick rundown of a specific data entity: its public OData name, datasources, key fields, and IsPublic status. Triggers: 'data entity info', 'OData entity details', 'is X a public entity', 'entity datasources'. Cloud-safe: pure metadata read from the KB. Input parameters: - `entityName` (string, required): Data entity name (AxDataEntityView), e.g. 'CustCustomerV3Entity', 'SalesOrderHeaderV2Entity'. ### `compare_objects` (~80 tokens) Compare two D365 F&O objects side-by-side (fields, methods, signatures). Handy when investigating differences between standard and a customisation, or between two similar tables. Input parameters: - `objectNameA` (string, required): First object name, e.g. 'SalesTable' - `objectNameB` (string, required): Second object name, e.g. 'PurchTable' ### `list_objects` (~247 tokens) WHEN: you need ALL objects of a given type or in a given model. Triggers: 'list all tables in ALM', 'show all classes', 'quels objets dans le modèle', 'give me all forms'. Full index scan -- returns EVERY matching object, not just top search results. Use to discover what tables, classes, forms, enums, etc. exist in a specific model. When no filters are given and a custom model is configured, defaults to listing that model. NOT for a single object -- use get_object_details. NOT for natural language search -- use search_d365_code. Input parameters: - `aotType` (string|null): Filter by AOT type: AxClass, AxTable, AxForm, AxView, AxEnum, AxEdt, AxDataEntityView, AxSecurityPrivilege, AxSecurityDuty, AxSecurityRole, AxQuery, AxReport, Documentation. Leave empty for all types. - `modelName` (string|null): Filter: matches BOTH package/module name (partial) AND object name (substring). Examples: 'ALM' (package), 'Cust' (any object containing 'Cust'), 'SalesTable'. Leave empty for all. ### `explain_workflow` (~187 tokens) WHEN: user asks how an approval workflow works, who approves a document, what states it goes through, or what happens on submission/rejection. NOT for technical workflow class details -- use `get_object_details`. WORKFLOW EXPLAINER (Business Language) -- Explains a D365 approval workflow: who approves, what states exist, and what happens on approval or rejection. Output is plain business language -- no X++ or workflow engine jargon. Triggers: 'explain the workflow for', 'how does the approval work', 'qui approuve', 'workflow states for', 'étapes du workflow', 'approval process for', 'circuit d\'approbation', 'what happens when a user submits'. Input parameters: - `objectName` (string, required): D365 object or workflow name, e.g. 'SalesTable', 'PurchTable', 'ALMDemandeAchatWorkflow' ### `trace_role_license_tree` (~383 tokens) WHEN: security design, licence audit, or 'what licence does this role require?'. Triggers: 'arborescence du rôle', 'licence nécessaire pour', 'what licence for role', 'role tree', 'droits du rôle', 'entry points of role', 'privilege tree for'. Builds the COMPLETE tree for ONE role: Role -> Duties -> Privileges -> Entry Points. For each entry point, classifies the required D365 licence per the March 2026 Licensing Guide: Team Members (~$8/user/mo, read-only + named tasks), Operations-Activity (~$50, warehouse mobile & production floor), Finance (~$180), Supply Chain Mgmt (~$180), Human Resources (~$22), Project Operations (~$120), Commerce (~$180). Grant-level aware: NoAccess/Read/View -> Team Members; Activity writes -> Operations-Activity; transactional writes -> full product licence based on functional area. Confidence: High (known module prefix) . Medium (keyword) . Low (fallback). Ends with a Optimization section: Team Members / Activity eligibility, role-split opportunities, per-user/month cost estimates (March 2026 MSRP). Always validate against the [Microsoft D365 Licensing Guide](https://go.microsoft.com/fwlink/?LinkId=866544). For a full multi-role scan, call `trace_role_license_tree` multiple times -- once per role. NOT for the pure technical duty/privilege/entry-point chain without licence inference -- use `trace_security_chain` for that. Input parameters: - `maxEntryPoints` (integer): Maximum entry points to show per privilege (default: 20, max: 100) - `roleName` (string, required): The exact security role name, e.g. 'SystemAdministrator', 'AccountsPayablePaymentsClerk', 'ALMMyCustomRole' ### `prepare_release_note_context` (~475 tokens) WHEN: building an AI-assisted D365 F&O upgrade release note (regressions + opportunities) for a specific client, and you (the calling assistant) want to do the reasoning yourself instead of the server calling its own LLM. Call resolve_client_profile FIRST -- if it finds a profile, OMIT v1/v2/customModelIds here and they will be auto-filled from it. If no profile exists, call list_release_note_inputs to get real values and pass them explicitly -- never guess them. Triggers: 'release note', 'upgrade impact for this client', 'what breaks for a client between these versions', 'regression risk', 'note de version'. Diffs two indexed D365FO versions (v1=older, v2=newer) and cross-references EVERY changed standard object against ALL the given custom models (a client can have several -- their own extensions AND a separate ISV vendor model, in which case pass both ids comma-separated) -- returning ONLY the subset of changes actually touched by the client's code (capped at 60, Removed > Modified > Added priority), each with old/new content and which custom object references it. Returns a JSON payload with an 'instructions' field telling you the EXACT schema to produce -- analyze the 'objects' array yourself, then call generate_release_note_document with your findings JSON to get the downloadable Word/PowerPoint. Input parameters: - `businessContext` (string|null): Optional free-text business/functional context about the client (modules used, key customizations, priorities) to sharpen the opportunity/regression assessment. - `customModelIds` (string|null): Comma-separated custom model id(s) from the Admin > Custom Models tab. Omit to auto-fill from the caller's resolved client profile. Pass several when a client combines their own extensions with a sep… - `v1` (string|null): Older/baseline D365FO version to compare FROM, e.g. "10.0.2527.109". Omit to auto-fill from the caller's resolved client profile (see resolve_client_profile). - `v2` (string|null): Newer D365FO version to compare TO, e.g. "10.0.2645.32". Omit to auto-fill from the caller's resolved client profile. ### `ado_analyze_workitem` (~714 tokens) AZURE DEVOPS ONLY -- Fetch a Work Item and assemble ALL technical context needed for D365 F&O expert analysis. [~] PRIORITY TRIGGER: 'analyse le workitem', 'analyse la tâche', 'analyse le FDD/RDD/CR/IDD', 'read the work item', 'check the bug', 'look at ticket', 'review task', '#1234', 'WI#', 'WI ', 'item #'. NEVER for: labels (@SYS/@TRX/@FIN), X++ code lookup, AOT objects -- use search_labels / search_d365_code instead. \## WHAT THIS TOOL RETURNS Raw structured context only -- NOT a finished analysis. The tool returns: 1\. Work item metadata (title, description, repro steps, acceptance criteria, comments) 2\. D365 standard KB object details: fields, methods, code snippets for every matched object 3\. Custom code on disk (customer extension model): existing CoC methods, extension bodies 4\. Chain of Command / relation graph for all impacted objects \## YOUR JOB AS COPILOT AFTER CALLING THIS TOOL You MUST synthesize the raw context into a precise developer-ready analysis IN FRENCH. Write it in a professional tone, as if authored by a senior D365 consultant -- no emojis, no icons. The analysis must contain these sections: 1\. **Compréhension du besoin** -- résume ce que le client demande en 2-3 phrases claires 2\. **Analyse technique** -- identifie la cause racine en croisant le besoin + les objets KB + le code custom 3\. **Instructions de développement** -- liste ordonnée et précise : quel objet, quelle méthode, quoi modifier - Si une extension custom existe sur disque -> pointer exactement quelle méthode à modifier - Si pas d'extension -> indiquer quel CoC créer, sur quel objet standard, quelle méthode 4\. **Estimation** -- chiffrage en heures/jours selon la complexité détectée 5\. **Commentaire ADO** -- Texte markdown sans icônes, prêt à poster sur le WI analysé UNIQUEMENT. IMPORTANT: never post (never call ado_post_comment) on any linked/related work item -- only on the analyzed WI. Requires DEVOPS_ORG_URL + DEVOPS_PAT env vars. Input parameters: - `focusObjects` (string|null): Comma-separated D365 object names to force-include in KB analysis, e.g. 'SalesTable,CustTable'. Providing these speeds up analysis significantly. - `includeImages` (boolean): Include image attachments as base64 data URIs for visual analysis by Copilot. Default: false. Set true only when screenshots are needed -- adds latency and token cost. - `maxComments` (integer): Number of recent comments to include (default 5, max 20). Use 3 for faster results. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `sourceBranch` (string): Git branch to read custom code from when no PR or commit is linked to the work item. Default: 'main'. Use this to point at the integration branch (e.g. 'develop', 'release/2025'). - `workItemId` (integer, required): Work item ID (integer), e.g. 1234 ### `ado_wiki_create_or_update_page` (~221 tokens) AZURE DEVOPS ONLY -- Create a new wiki page, or OVERWRITE an existing one with new markdown content. ALWAYS call ado_wiki_get_page first if you intend to edit (not replace) an existing page's content, since this tool replaces the ENTIRE page body -- it does not merge/append. Automatically handles the page's ETag for safe concurrent-edit detection. Requires DEVOPS_ORG_URL + DEVOPS_PAT env vars (PAT needs Wiki: Read & Write scope). Input parameters: - `content` (string, required): Full markdown content for the page (replaces any existing content). - `path` (string, required): Wiki page path, e.g. '/Home' or '/Architecture/Deployment'. Parent pages are created automatically if missing. - `project` (string|null): Optional: Azure DevOps project name. Falls back to DEVOPS_PROJECT env var. - `wikiIdentifier` (string|null): Wiki name or id. Omit to auto-resolve to the project's only/first wiki (call ado_wiki_list if there are several). ### `resolve_workspace_roots` (~74 tokens) WHEN: you need to know which folder(s) are configured as the workspace/project root for the current caller. Reads D365-Custom-Model-Path and D365-Standard-Model-Path from the request headers or environment variables. Use before any tool that accepts a customModelPath/standardModelPath parameter. ### `resolve_client_profile` (~149 tokens) WHEN: at the START of any release-note / upgrade-impact conversation -- call this BEFORE list_release_note_inputs to check whether a Client Profile already exists for the CURRENT caller's Azure DevOps org/project (auto-detected from DEVOPS_ORG_URL/DEVOPS_PROJECT MCP headers -- you don't pass anything). If found, it gives you the client's currentVersionTag, targetVersionTag, customModelIds (their own extensions AND any attached ISV/vendor models) and the latest diff snapshot in one call -- use those directly as v1/v2/customModelIds for prepare_release_note_context, no further discovery needed. If not found, fall back to list_release_note_inputs and/or save_client_profile. ### `generate_unit_test` (~358 tokens) WHEN: developer needs to write or scaffold unit tests for a custom D365 object. Triggers: 'generate tests', 'unit test', 'SysTest', 'write test for', 'scénarios de test', 'test this class'. Generate X++ SysTest unit test code for a CUSTOM D365 F&O object based on functional test scenarios. [!] Only meaningful on custom/extension code (D365_CUSTOM_MODEL_PATH). SysTest tests in D365 are highly context-specific -- a generic template rarely compiles without adaptation. REQUIRED: provide test scenarios in the 'testScenarios' parameter (supplied by the functional consultant). Each scenario becomes a concrete test method with arrange/act/assert. For tables: generates tests for find(), exist(), validateWrite(), initValue(). For classes: generates stubs for each public method listed in scenarios. Uses REAL field names and method signatures from the knowledge base. Input parameters: - `methodName` (string|null): Optional: specific method to test. If not provided, generates tests for all testable methods. - `objectName` (string, required): Object name to generate tests for, e.g. 'ALMERSftpConnectionTable', 'ALMMyClass' - `sampleValues` (string|null): Optional: JSON object mapping field name to sample value used in each ARRANGE block, e.g. '{"AccountNum":"C0001","Amount":1500.50}'. Replaces the 'TODO: set up test data' placeholders with concrete a… - `testScenarios` (string|null): Test scenarios provided by the functional consultant, e.g. 'Create a connection with valid SFTP host; Validate that empty host fails; Delete cleans up related records'. Separate scenarios with semico… ### `create_aot_object` (~1648 tokens) Generate a complete, ready-to-deploy D365 F&O AOT XML scaffold for any object type. Returns the XML + the correct file path inside the model -- the calling client (VS Extension, Cursor, Copilot Chat) is responsible for writing the result to disk. This tool is fully read-only on the server: it never writes to the filesystem, never mutates external state, and is safe to expose from the cloud MCP. When the knowledge base is available the scaffold is auto-enriched with real metadata (existing field EDTs, related-table validation, auto-detected grid fields, etc.). Supported aotType values ---------------------------------------------- AxTable . AxClass . AxForm . AxEnum AxEdt . AxView . AxQuery . AxDataEntityView AxMenuItemDisplay . AxMenuItemAction . AxMenuItemOutput AxSecurityPrivilege . AxSecurityDuty . AxSecurityRole . AxSecurityPolicy AxReport . AxFormExtension . AxTableExtension . AxClassExtension AxEnumExtension . AxEdtExtension . AxQueryExtension . AxWorkflow Common options (all types) -------------------------------------------- label - human-readable label shown in the UI developerDoc - developer documentation string (tables/classes) AxTable -------------------------------------------------------------------------- tableGroup - Main | WorksheetHeader | WorksheetLine | Transaction | Parameter | Group cacheLookup - None | Found | FoundAndEmpty | NotInTTS | EntireTable fields - csv "Name:Type[:EDT[:Label[:mandatory]]]" Types: String Int Int64 Real Date DateTime Enum Container Guid indexes - csv "IndexName:field1+field2[:unique|:alternatekey]" relations - csv "RelName:RelatedTable:Field:RelatedField" titleField1/2 - field names for the lookup title createdBy / modifiedBy - true | false (default true) generateFind / gener… Input parameters: - `aotType` (string, required): AOT type, e.g. 'AxTable', 'AxClass', 'AxForm', 'AxEnum', 'AxEdt', 'AxSecurityPrivilege', etc. - `name` (string, required): Object name -- must start with the ISV prefix, e.g. 'ALMMyTable', 'ABCSalesService'. - `options` (object|null): Key-value options dict. Provide only the keys relevant to your aotType. Example for AxTable: { "label": "My Table", "tableGroup": "Main", "fields": "MyId:String:MyIdEdt:My ID:m… ### `d365fo_set_connection` (~237 tokens) Securely register the D365 F&O connection (URL + Entra app-registration credentials) for the CURRENT session. The client secret is encrypted in memory (AES-256-GCM), never written to disk and never echoed back. Once set, all odata_* and dmf_* tools use it automatically until it expires or you call d365fo_clear_connection. Use this instead of resending the secret on every call. In a locked server deployment (D365FO_LOCK_SERVER_CONFIG=true) this tool is disabled and the server's own environment credentials are used instead. Input parameters: - `baseUrl` (string, required): F&O environment base URL, e.g. https://yourenv.cloudax.dynamics.com (https only). - `clientId` (string, required): App registration (client) id (GUID). - `clientSecret` (string, required): App registration client secret. Encrypted in memory; never logged or persisted. - `tenantId` (string, required): Entra (Azure AD) tenant id (GUID). - `ttlMinutes` (integer): Minutes the connection stays cached for this session (1-480). Default 60. ### `appinsights_clear_connection` (~28 tokens) Removes the Application Insights connection cached for the current session by appinsights_set_connection. ### `generate_data_entity` (~308 tokens) WHEN: developer needs to CREATE a data entity (AxDataEntityView) AOT XML from a table for OData/DMF/data migration. Triggers: 'create data entity', 'generate entity', 'créer une data entity', 'exposer table via OData', 'DMF entity', 'entity for OData', 'entité de données', 'générer entity XML', 'AxDataEntityView pour', 'data entity from table'. Produces complete AxDataEntityView AOT XML with data sources, field mappings, entity key, IsPublic/PublicEntityName for OData, staging table template. Uses real field names and relations from the local custom model. ALWAYS call find_entity_for_table first to verify a standard entity doesn't already exist. Input parameters: - `entityName` (string, required): Desired entity name, e.g. 'ALMSalesOrderEntity' - `fields` (string|null): Optional: specific fields to include (comma-separated). All fields if not specified. - `isPublic` (boolean): Whether the entity should be available via OData (default: true) - `joinTables` (string|null): Optional: additional tables to join (comma-separated), e.g. 'CustTable,InventDim' - `publicEntityName` (string|null): Optional: OData collection name (e.g. 'SalesOrders'). Auto-generated if not provided. - `tableName` (string, required): Primary table name, e.g. 'SalesTable', 'CustTable' ### `find_event_handlers` (~216 tokens) Find all event handlers that subscribe to events on a D365 table or class. Searches the knowledge base for [SubscribesTo(classStr(objectName), ...)] / [SubscribesTo(tableStr(objectName), ...)] attribute patterns. Use eventName to narrow results to a specific event (e.g. 'OnInserted'). WHEN: 'who handles X', 'what subscribes to Y', 'event handlers for Z', 'qui écoute l'événement', 'abonnés à l'événement', 'SubscribesTo', 'data events for'. Input parameters: - `eventName` (string|null): Optional: filter to a specific event name, e.g. 'OnInserted', 'OnUpdated', 'OnDeleted', 'OnValidatingWrite'. - `handlerType` (string|null): Optional: filter by handler type — 'DataEventHandler' or 'PrePostEventHandler'. - `objectName` (string, required): Table or class name to find event handlers for, e.g. 'SalesTable', 'PurchTable'. ### `generate_xpp_form` (~314 tokens) Generate a complete, compilable AxForm AOT XML with the CORRECT control serialization (