Upgrade Azure.AI.OpenAI to v2.1.0, add RoadmapCrew & AgentTeamFramework

[JustAGhosT]

Summary

• Upgrade Azure.AI.OpenAI from v1.0.0-beta.14 to v2.1.0 stable across all LLM call sites (10+ files in ReasoningLayer, MetacognitiveLayer, FoundationLayer, AgencyLayer)
• Add AgentTeamFramework — reusable base for multi-agent pipeline teams with prompt management, LLM adapter, and test kit
• Add RoadmapCrew agent team — 6-agent pipeline (Researcher, Analyzer, Strategist, PriorityRanker, RiskAssessor, PlanWriter) with 23 unit tests
• Merge dependency updates — Renovate and Dependabot bumps for Polly, MediatR, Npgsql, WolverineFx, Storybook, ESLint, i18next, react-i18next
• Fix System.CommandLine 2.0.3 breaking changes in MeshSimRuntime (SetAction, Parse().InvokeAsync)
• Fix build issues — namespace resolution for IFeatureFlagManager, malformed TestProject.csproj, MCP server configuration

Key API migration patterns (Azure.AI.OpenAI v2)

• OpenAIClient → AzureOpenAIClient + ChatClient via GetChatClient(deployment)
• ChatCompletionsOptions → ChatCompletionOptions with separate message collection
• ChatRequestSystemMessage/UserMessage → SystemChatMessage/UserChatMessage (from OpenAI.Chat)
• response.Value.Choices[0].Message.Content → completion.Value.Content[0].Text
• MaxTokens → MaxOutputTokenCount

Test plan

• dotnet build CognitiveMesh.sln — 0 errors, 0 warnings
• dotnet test CognitiveMesh.sln — verify all existing + new tests pass
• Verify RoadmapCrew 23 tests pass independently
• Smoke test MeshSimRuntime CLI commands

🤖 Generated with Claude Code

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your settings.

[greptile-apps]

Your free trial has ended. If you'd like to continue receiving code reviews, you can add a payment method here.

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: e95b11e4-2cbf-499e-a95c-f41cf551ff58

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch dev

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Summary

Summary

Generated on:	03/10/2026 - 06:48:48
Parser:	MultiReport (10x OpenCover)
Assemblies:	1
Classes:	4
Files:	3
Line coverage:	30.9% (13 of 42)
Covered lines:	13
Uncovered lines:	29
Coverable lines:	42
Total lines:	210
Branch coverage:	37.5% (6 of 16)
Covered branches:	6
Total branches:	16
Method coverage:	Feature is only available for sponsors

Coverage

CognitiveMesh.Shared - 30.9%

Name	Line	Branch
CognitiveMesh.Shared	30.9%	37.5%
CognitiveMesh.Shared.Interfaces.ChatMessage	0%	0%
CognitiveMesh.Shared.LogSanitizer	56.5%	50%
CognitiveMesh.Shared.Models.PolicyConfiguration	0%
CognitiveMesh.Shared.Models.RoutingRule	0%

In general, the fix is to replace the generic catch (Exception ex) with more specific catch clauses for the exception types that are expected and can be meaningfully turned into a SpecializedTaskResult, and allow other exceptions to propagate. At minimum, we should avoid trapping exceptions that indicate a serious application/environment failure.

The best targeted fix, without changing external functionality more than necessary, is:

• Keep the existing catch (OperationCanceledException) as-is and continue rethrowing it.
• Add one or more specific catch blocks for common, recoverable failures that can occur during the LLM call (for example, TimeoutException and TaskCanceledException when the LLM port times out or cancels internally).
• Replace the generic catch (Exception ex) with a catch whose pattern excludes critical exceptions (such as OutOfMemoryException, StackOverflowException, ThreadAbortException) using C#’s exception filters. Since we cannot change behavior outside this file nor know the full exception set from _llmPort, we will keep the logging and result-generation behavior for the non-critical exceptions, but ensure that truly fatal ones are not swallowed.

Concretely, in ExecuteTaskAsync:

• Replace catch (Exception ex) with separate specific catches for TimeoutException and TaskCanceledException, which both log and return a SpecializedTaskResult describing the failure.
• Add a final filtered catch: catch (Exception ex) when (ex is not OutOfMemoryException && ex is not StackOverflowException && ex is not ThreadAbortException) that retains the current behavior for all remaining non-fatal exceptions.
• No new imports are required because TimeoutException, TaskCanceledException, and the fatal exception types are all in System.

This keeps the public contract (method still returns SpecializedTaskResult on most errors) while avoiding a purely generic catch and improving robustness for catastrophic failures.

---

In general, to fix this kind of issue, you replace a loop that conditionally processes elements (if (predicate(item)) { ... }) with an explicit filter using Where (or another LINQ method), then iterate or aggregate over the filtered sequence. This expresses the intent more clearly and removes the inner conditional or continue.

In this specific case, the inner loop:

var score = 0;
foreach (var required in task.RequiredCapabilities)
{
    if (agent.Capabilities.Contains(required, StringComparer.OrdinalIgnoreCase) ||
        agent.Domains.Contains(required, StringComparer.OrdinalIgnoreCase))
    {
        score++;
    }
}

is effectively “count how many required items satisfy the predicate.” The most direct LINQ equivalent is:

var score = task.RequiredCapabilities.Count(required =>
    agent.Capabilities.Contains(required, StringComparer.OrdinalIgnoreCase) ||
    agent.Domains.Contains(required, StringComparer.OrdinalIgnoreCase));

This both eliminates the inner foreach and uses an explicit predicate, satisfying the analyzer’s recommendation without changing logic. To implement this, we only need to modify the body of FindBestAgentAsync in src/AgencyLayer/AgentTeamFramework/Adapters/LLMBackedSpecializedAgentAdapter.cs at the region around lines 139–158. LINQ extension methods like Count live in System.Linq; we are not shown the using directives beyond lines 1–5, and none of them include System.Linq. Because we cannot edit unseen parts of the file, we should use the fully qualified method name System.Linq.Enumerable.Count(...) to avoid adding a new using. No other methods, imports, or definitions are required.

---

In general, to avoid Path.Combine silently discarding earlier components when a later component is absolute, replace Path.Combine with Path.Join where you are simply concatenating path segments and do not want absolute segments to override earlier ones.

For this specific case, change the construction of directPath on line 161 from Path.Combine(_basePath, "Prompts") to Path.Join(_basePath, "Prompts"). Path.Join is available in System.IO in modern .NET, requires no extra imports beyond what already exists indirectly, and preserves earlier segments even if a later one is absolute. This change keeps the intended functionality (building {basePath}/Prompts) while eliminating the potential for silent dropping of _basePath if "Prompts" were ever changed to an absolute path.

Only the line defining directPath in FindPromptsDirectory needs modification; no additional methods or definitions are required.