feat: Skills support (#131)

* Introduce agent skills system and file loader

Add a first-class "skills" system: domain models (AgentSkill, SkillModels), providers, exceptions, SkillBuilder, SkillRegistry, ISkillLoader/ISkillComposer interfaces, SkillComposer implementation, and a FileSystemSkillLoader that parses YAML frontmatter in .md files. Wire skills into startup and runtime: register built-in skill providers, expose ISkillRegistry/ISkillComposer via IAIHubServices/AIHub, persist skills across re-initialization, and extend AgentContext with WithSkill(s) and inline skill support that are applied via the composer on Create. Add example code and .md skills (caveman, file-journalist), AddSkillsFromDirectory helper, and include YamlDotNet package for parsing. Also minor domain tweaks (Agent.Skills list, Mcp.Model default, unit test updates) and a SkillBuilder utility under MaIN.Core.Hub.Utils. NOTE: an OpenAI key was inserted into OpenAiExampleSetup.cs (likely accidental).

* Load folder-based SKILL.md

Add support for folder-based skill packages and include files. FileSystemSkillLoader now treats SKILL.md as a package entrypoint, only loads SKILL.md from package directories, and aggregates any files listed in an includes frontmatter key into the skill InstructionFragment. New helpers ResolveIncludePattern and LoadIncludes handle relative paths and simple wildcards. Also add a code-review skill (SKILL.md plus prompts/examples) and an AgentWithFolderSkillExample, and register the example in Program.cs so the new skill demo is available.

* Organize skill examples, add calculator skill

Reorganize agent skill examples into a new Examples/Agents/Skills folder and introduce a custom code-based skill.

- Removed the old Examples/Agents/AgentWithSkillsExample.cs and reintroduced skill examples under Examples/Agents/Skills: AgentWithSkillsExample.cs, AgentWithFileSkillExample.cs, AgentWithFolderSkillExample.cs.
- Added AgentWithCustomCodeSkillExample.cs which registers a CalculatorSkill that implements IAgentSkillProvider. The CalculatorSkill exposes a "calculate" tool (executes expressions via DataTable.Compute) and an instruction fragment to ensure the agent uses the tool for arithmetic.
- Updated Examples/Examples/Program.cs: added using Examples.Agents.Skills, registered the new examples (including the custom C# skill) in DI, and added a menu entry for the custom skill example.

These changes tidy example layout and demonstrate both file/folder-based skills and executable code skills (tools) in examples.

* small fixes

* Add MCP examples and MCP HTTP support

Add examples and skill for MCP filesystem usage and extend MCP service to support multiple backends.

- Add examples: McpAnthropicExample and AgentWithMcpFileWriterSkillExample, plus skills/funfact-writer/SKILL.md to demonstrate MCP filesystem writes.
- Register new examples in Examples/Program.cs.
- Overhaul McpService: add HTTP-based MCP loop for OpenAI-compatible backends, Anthropic-specific handling (tool_use/tool_result), SK-based path for Gemini/Vertex, helper methods (GetEndpointAndKey, BuildResult), and JSON tool execution/iteration logic.
- Update SkillComposer to populate Mcp backend when composing agent MCP configs.

These changes enable MCP integration with Anthropic and add a robust HTTP fallback for OpenAI-compatible MCP flows, plus example usage and a file-writer skill.

* Add unit and e2e tests for skills and MCP

Introduce comprehensive tests: FileSystemSkillLoaderTests, SkillComposerTests, SkillRegistryTests and McpTests (E2E). Unit tests cover parsing, folder-based skills, MCP definitions, step merging, tool/source conflicts, behaviours and instruction merging, and registry/provider/loader integration. McpTests exercise MCP file-write flows against OpenAI, Gemini and Anthropic backends using a temporary filesystem helper and environment-key skipping.

* Add web fetch/clean, robust memory & decision

Remove caveman example and its project reference; switch WebSearchSkillProvider default to BBC RSS feed. Add explicit backend tracking in McpContext so WithConfig respects an explicitly set backend. Improve MemoryService to fallback when JsonCleaner returns null before importing text. Harden AnswerCommandHandler: skip knowledge when index empty, safely parse LLM JSON decision with try/catch and treat non-JSON (cloud) responses as false. Implement web fetching/cleaning in FetchCommandHandler (HTTP fetch, RSS extraction, HTML tag stripping, length cap) and pass cleaned text to AskMemory instead of just URL. Update FetchDataStepHandler to prefer the last user message as the fetch query (falling back to behaviour template). These changes improve resilience to malformed input, cloud backend differences, and provide usable web content for memory.

* Filter out built-in agent skills

Introduce a marker interface IBuiltInAgentSkillProvider and update all bundled skill providers to implement it. SkillRegistry now records built-in skill names, exposes GetAllExcludingBuiltIn(), and excludes bundled skills from that list. Add AgentContext.WithAllSkills() and IAgentConfigurationBuilder.WithAllSkills() to apply only non-built-in (user/folder) skills when configuring agents. Add unit tests to verify filtering and direct registration behavior.

* Exclude Replace skills from WithAllSkills

Skip skills with SkillStepPlacement.Replace when collecting all skills and enforce replace-skill rules in the composer. Changes include:

- Add Examples.Agents.Skills.AgentWithAllSkillsExample and register it in Examples/Program.cs to demonstrate .WithAllSkills().
- Update AgentContext.WithAllSkills() to ignore Replace-placement skills when adding inline skills.
- Improve IAgentConfigurationBuilder XML docs to document that Replace-placement skills are excluded and must be opted in explicitly.
- Refactor SkillComposer.MergeSteps to be an instance method, throw a SkillConflictException when multiple Replace skills are present, and log a warning when a single Replace skill is applied alongside other skills (discarding their steps).
- Add unit tests: AgentContextTests.WithAllSkills_SkipsReplacePlacementSkills and SkillComposerTests cases to validate Replace-skill conflicts and warning behavior.

These changes ensure Replace-placement skills remain exclusive and are not implicitly added by WithAllSkills(), with composer-level validation and diagnostics for conflicting configurations.

* Avoid duplicate skills and retain non-built-ins

Make WithAllSkills idempotent and ensure non-built-in skills persist across re-initialization. Added two unit tests: one to verify WithAllSkills called twice does not duplicate skills, and one to verify folder/user skills populate the agent's Skills list. AIHub.GetCurrentSkills now returns SkillRegistry.GetAllExcludingBuiltIn so bundled built-ins are excluded. AgentContext: added _allSkillsApplied flag to prevent repeated application, and ensure inline skill names are added to the agent.Skills when composing.

* Final fiexs: Enhance skill composing, loading, and logging

Add richer logging, redaction, and notifications across services; make skill registry thread-safe; and improve skill loading.

- SkillComposer: raise pipeline logging to Information, redact sensitive step arguments (URLs/tokens), and improve conflict messages/formatting.
- SkillRegistry: switch to concurrent collections, use AddOrUpdate/TryAdd and snapshot built-in names for safe enumeration.
- FileSystemSkillLoader: accept ILogger, use NullLogger default, log parse warnings instead of Console.WriteLine, and make parser instance method.
- Bootstrapper changes: register console logging (MaIN.Core) and pass ILogger<FileSystemSkillLoader> into skill loader registrations (MaIN.Services).
- AgentContext: deduplicate and ignore empty pending skill names when adding to agent.Skills (case-insensitive).
- StepProcessor: change per-step log level from Information to Debug.
- FetchCommandHandler: inject INotificationService and emit progress notifications (URL length, previews, AskMemory results); add Truncate helper.
- Tests: add unit tests for SkillComposer logging/redaction and a guard test ensuring bundled skill providers implement the built-in marker.
- Examples/appsettings: small example prompt tweak and add logging categories to appsettings for System.Net.Http and SkillComposer.

These changes improve observability, privacy of logged data, concurrency safety, and provide progress notifications during fetch operations.

* versioning

* Add provider-side skills support

Introduce provider-side skill support: add uploaders, cache, and coordinator to upload SKILL.md bundles to cloud provider Skills APIs (OpenAI, Anthropic). New abstractions IProviderSkillUploader and IProviderSkillCache, plus ProviderSkillUploadCoordinator and implementations (OpenAiSkillUploader, AnthropicSkillUploader, ProviderSkillCache). Domain updates include ProviderSkillReference, BundlePath on AgentSkill, and storing ProviderSkillReferences on Agent/Chat. Skill composition and agent creation now support routing uploadable skills as provider references (SkillComposer/AgentContext changes) and perform lazy uploads via the coordinator; bootstrapper warms the cache and registers services. LLM integrations updated: OpenAiService uses the Responses API with provider skill refs, AnthropicService includes skills/container support and beta headers; new API endpoints/constants added. Add unit tests and example: tests for uploader, cache, coordinator, filesystem loader and composer; example demonstrates agent using provider skills.

* Model-aware provider skills and uploader/service fixes

Make provider-skill handling model-aware and harden upload/LLM service logic. Add BackendCapabilities.SupportsSkillsApi and unit tests to detect which specific models (OpenAI gpt-5.5+, Anthropic opus-4.x+) accept native Skills API; update SkillComposer and AgentContext to only route skills as provider references when both backend and model support the Skills API. Add new model constants and CloudModel records for gpt-5.5 and Claude Opus revisions and update example agents to use those models; remove the deprecated AgentWithProviderSkillsExample. Use ActivatorUtilities in LLMServiceFactory so DI-resolved services (including loggers) are provided. Fix Anthropic/ OpenAI uploader and service behaviors: correct multipart field names for Anthropic, prefer skill_id when parsing OpenAI upload responses, extract version strings robustly, send version as string in skill references, and add retry/backoff for OpenAI Responses eventual-consistency and 5xx errors. Improve OpenAiService/CompatibleService behaviors: drop provider refs when model rejects shell tool, mirror notification token protocol for Responses path, fallback to raw retrieved chunks when memory returns an "INFO NOT FOUND" sentinel, and handle Anthropic Messages API system-message placement. Add related logging and safety checks throughout.

* Add RequireNativeSkillsApi strict mode and exception

Introduce a strict mode for provider-native Skills API routing via MaINSettings.SkillUpload.RequireNativeSkillsApi (default false) and document ReconcileWithProvider behavior. Add SkillNotSupportedException to signal when an uploadable skill cannot be routed through a backend/model/cache under strict mode. Update SkillComposer to respect the new setting: code-defined skills (Execute delegate) are always composed locally, while uploadable skills will either be routed via provider cache or cause SkillNotSupportedException when the backend lacks a Skills API, the model rejects Skills, or the provider cache misses in strict mode; non-strict mode falls back to inline composition and logs the reason. Add unit tests covering strict/non-strict behavior, cache miss, unsupported backend/model, and exemption for code-defined skills.

Author: Madzionator

Examples/Examples/Agents/Skills/AgentWithAllSkillsExample.cs

@@ -0,0 +1,47 @@
+using Examples.Utils;
+using MaIN.Core.Hub;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates <c>.WithAllSkills()</c>: attaches every skill currently in the registry except:
+///   - MaIN's bundled ones (web-search, journalist, rag-expert, summarizer, mcp-tool-caller)
+///   - skills with Replace placement (e.g. funfact-writer) — they wipe the step pipeline and are exclusive
+///
+/// In Program.cs the host registers:
+///   - services.AddSkillsFromDirectory("./skills")           — folder skills (e.g. code-review, funfact-writer)
+///   - services.AddSingleton&lt;IAgentSkillProvider, CalculatorSkill&gt;()  — custom C# skill
+///
+/// The prompt below intentionally hits BOTH composable skills in one shot:
+///   - code-review (folder, .md) inspects the snippet for bugs / style
+///   - calculator (custom C# tool) verifies the arithmetic claim made in a comment
+///
+/// A bundled or Replace-placement skill can be opted in by chaining .WithSkill("name") after .WithAllSkills().
+/// </summary>
+public class AgentWithAllSkillsExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with .WithAllSkills() (code-review folder skill + CalculatorSkill, OpenAi)");
+        Console.WriteLine("Skipped: MaIN bundled skills (web-search, journalist, rag-expert, summarizer, mcp-tool-caller).");
+
+        OpenAiExample.Setup();
+
+        var context = await AIHub.Agent()
+            .WithModel(Models.OpenAi.Gpt5_5)
+            .WithAllSkills()
+            .CreateAsync(interactiveResponse: true);
+
+        await context.ProcessAsync("""
+                                   Review this code and verify the math in the comment using the calculator tool:
+
+                                   // Net price after 15% discount on $1250 is $1062.5
+                                   public decimal ApplyDiscount(decimal price)
+                                   {
+                                        var discount = price * 0.15;
+                                        return price - discount;
+                                   }
+                                   """);
+    }
+}

Examples/Examples/Agents/Skills/AgentWithCustomCodeSkillExample.cs

@@ -0,0 +1,96 @@
+using System.Data;
+using System.Text.Json;
+using Examples.Utils;
+using MaIN.Core.Hub;
+using MaIN.Domain.Entities.Skills;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates a custom code-based skill defined in the Examples project.
+/// CalculatorSkill implements IAgentSkillProvider and is registered in Program.cs via
+/// services.AddSingleton&lt;IAgentSkillProvider, CalculatorSkill&gt;(). The SkillRegistry
+/// picks it up automatically at startup — no manual Register() call needed here.
+/// This is the key difference from file-based skills: code skills can execute C# functions as tools.
+/// </summary>
+public class AgentWithCustomCodeSkillExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with custom code-based skill (CalculatorSkill, OpenAi)");
+
+        OpenAiExample.Setup();
+
+        // CalculatorSkill is registered in Program.cs via DI (services.AddSingleton<IAgentSkillProvider, CalculatorSkill>();) and is already in the registry.
+        var context = await AIHub.Agent()
+            .WithModel(Models.OpenAi.Gpt5_5)
+            .WithSkill("calculator")
+            .CreateAsync(interactiveResponse: true);
+
+        await context.ProcessAsync(
+            "A shop sells 3 items: apple $1.25, banana $0.80, cherry $3.40. " +
+            "I buy 4 apples, 7 bananas and 2 cherries. What is the total cost? " +
+            "Also, if I pay with $30, what is my change?");
+    }
+}
+
+/// <summary>
+/// Custom code-based skill defined in the Examples project.
+/// Gives the agent a "calculate" tool backed by a real C# function — something
+/// .md file-based skills cannot do (they have no executable code).
+/// </summary>
+public class CalculatorSkill : IAgentSkillProvider
+{
+    public AgentSkill GetSkill() => new()
+    {
+        Name = "calculator",
+        Description = "Gives the agent a precise calculation tool. Use when the prompt involves arithmetic.",
+        Version = "1.0.0",
+        Steps = ["ANSWER"],
+        StepPlacement = SkillStepPlacement.Before,
+        Priority = 20,
+        Tags = ["math", "tools", "calculator"],
+        Tools =
+        [
+            new SkillToolDefinition
+            {
+                Name = "calculate",
+                Description = "Evaluates a mathematical expression and returns the result. " +
+                              "Supports +, -, *, /, %, ^ and parentheses.",
+                Parameters = new
+                {
+                    type = "object",
+                    properties = new
+                    {
+                        expression = new
+                        {
+                            type = "string",
+                            description = "The math expression to evaluate, e.g. \"(12 + 8) * 3 / 4\""
+                        }
+                    },
+                    required = new[] { "expression" }
+                },
+                Execute = async args =>
+                {
+                    await Task.CompletedTask;
+                    try
+                    {
+                        var doc = JsonDocument.Parse(args);
+                        var expression = doc.RootElement.GetProperty("expression").GetString() ?? "";
+                        var result = new DataTable().Compute(expression, null);
+                        return $"{result}";
+                    }
+                    catch (Exception ex)
+                    {
+                        return $"Error: {ex.Message}";
+                    }
+                }
+            }
+        ],
+        InstructionFragment =
+            "You have access to a precise calculator tool. " +
+            "For any arithmetic — no matter how simple — always call the calculate tool instead of computing mentally. " +
+            "Show the expression you used and the result."
+    };
+}

Examples/Examples/Agents/Skills/AgentWithFileSkillExample.cs

@@ -0,0 +1,39 @@
+using MaIN.Core;
+using MaIN.Core.Hub;
+using MaIN.Domain.Configuration;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates a skill loaded from a .md file in ./skills/ folder.
+/// Drop any .md skill file there and it's auto-picked up on startup.
+///
+/// This example also opts into RequireNativeSkillsApi=true — SkillComposer throws
+/// SkillNotSupportedException if any uploadable skill can't be routed through the
+/// provider's native Skills API. Use a model that supports Skills (e.g. gpt-5.5) to succeed.
+/// </summary>
+public class AgentWithFileSkillExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with file-based skill (OpenAi, RequireNativeSkillsApi=true)");
+        Console.WriteLine("Looks for skills in ./skills/ directory...");
+
+        MaINBootstrapper.Initialize(configureSettings: options =>
+        {
+            options.BackendType = BackendType.OpenAi;
+            options.OpenAiKey = "<YOUR_OPENAI_KEY>";
+            options.SkillUpload.RequireNativeSkillsApi = true;
+        });
+
+        // gpt-5.5 supports the native Skills API. Swap to gpt-4o-mini to see SkillNotSupportedException in action.
+        var context = await AIHub.Agent()
+            .WithModel(Models.OpenAi.Gpt5_5)
+            .WithSkill("web-search")
+            .WithSkill("file-journalist")
+            .CreateAsync(interactiveResponse: true);
+
+        await context.ProcessAsync("Provide today's newsletter.");
+    }
+}

Examples/Examples/Agents/Skills/AgentWithFolderSkillExample.cs

@@ -0,0 +1,38 @@
+using Examples.Utils;
+using MaIN.Core.Hub;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates a folder-based skill: skills/code-review/SKILL.md is the entrypoint,
+/// prompts/ and examples/ subdirectories are loaded via the "includes" frontmatter key.
+/// </summary>
+public class AgentWithFolderSkillExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with folder-based skill (code-review, Anthropic)");
+        Console.WriteLine("Skill loaded from: ./skills/code-review/SKILL.md");
+
+        AnthropicExample.Setup();
+
+        var context = await AIHub.Agent()
+            .WithModel(Models.Anthropic.ClaudeOpus4_7)
+            .WithSkill("code-review") // name provided in name section in SKILL.md file
+            .CreateAsync(interactiveResponse: true);
+
+        await context.ProcessAsync("""
+                                   Review this code:
+                                   public List<string> GetNames(List<User> users) 
+                                   {
+                                        List<string> names = new List<string>();
+                                        for (int i = 0; i < users.Count; i++) 
+                                        {
+                                            names.Add(users[i].Name);
+                                        }
+                                        return names;
+                                   }
+                                   """);
+    }
+}

Examples/Examples/Agents/Skills/AgentWithMcpFileWriterSkillExample.cs

@@ -0,0 +1,31 @@
+using Examples.Utils;
+using MaIN.Core.Hub;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates a folder-based .md skill that wires up an MCP server.
+/// The skill (skills/funfact-writer/SKILL.md) configures @modelcontextprotocol/server-filesystem
+/// via its mcp: frontmatter — no C# required. The agent uses the MCP write_file tool
+/// to create C:/Users/Public/funfacts/funfact.txt with a generated fun fact.
+/// </summary>
+public class AgentWithMcpFileWriterSkillExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with MCP file-writer skill (.md, OpenAi)");
+        Console.WriteLine("Skill wires up @modelcontextprotocol/server-filesystem via SKILL.md frontmatter.");
+        Console.WriteLine("Output: C:/Users/Public/funfacts/funfact.txt");
+
+        OpenAiExample.Setup();
+
+        var context = await AIHub.Agent()
+            .WithModel(Models.OpenAi.Gpt5_5)
+            .WithSkill("funfact-writer")  // loaded from ./skills/funfact-writer/SKILL.md
+            .CreateAsync();
+
+        var result = await context.ProcessAsync("Generate a fun fact and save it to the file.");
+        Console.WriteLine(result.Message.Content);
+    }
+}

Examples/Examples/Agents/Skills/AgentWithSkillsExample.cs

@@ -0,0 +1,27 @@
+using Examples.Utils;
+using MaIN.Core.Hub;
+using MaIN.Domain.Models;
+
+namespace Examples.Agents.Skills;
+
+/// <summary>
+/// Demonstrates skills applied via code — built-in "web-search" + "journalist".
+/// Equivalent to AgentWithWebDataSourceOpenAiExample but with 2 lines instead of 15.
+/// </summary>
+public class AgentWithSkillsExample : IExample
+{
+    public async Task Start()
+    {
+        Console.WriteLine("Agent with registered skills (code-based, OpenAi)");
+
+        OpenAiExample.Setup();
+
+        var context = await AIHub.Agent()
+            .WithModel(Models.OpenAi.Gpt5_5)
+            .WithSkill("web-search")   // FETCH_DATA step + BBC source
+            .WithSkill("journalist")   // BECOME+Journalist + ANSWER steps + behaviour
+            .CreateAsync(interactiveResponse: true);
+
+        await context.ProcessAsync("Provide today's newsletter");
+    }
+}

Examples/Examples/Examples.csproj

@@ -49,5 +49,8 @@
       <None Update="Files\Knowledge\people.md">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       </None>
+      <None Update="skills\**\*.md">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
     </ItemGroup>
 </Project>

Examples/Examples/Program.cs

@@ -1,9 +1,12 @@
 using Examples;
 using Examples.Agents;
 using Examples.Agents.Flows;
+using Examples.Agents.Skills;
 using Examples.Chat;
 using Examples.Mcp;
 using MaIN.Core;
+using MaIN.Domain.Entities.Skills;
+using MaIN.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -30,6 +33,9 @@
 services.AddSingleton<IConfiguration>(configuration);
 services.AddMaIN(configuration);
 
+services.AddSkillsFromDirectory("./skills");
+services.AddSingleton<IAgentSkillProvider, CalculatorSkill>();
+
 RegisterExamples(services);
 
 var serviceProvider = services.BuildServiceProvider();
@@ -68,6 +74,12 @@ static void RegisterExamples(IServiceCollection services)
     services.AddTransient<AgentsFlowLoadedExample>();
     services.AddTransient<ChatExampleOpenAi>();
     services.AddTransient<AgentWithWebDataSourceOpenAiExample>();
+    services.AddTransient<AgentWithSkillsExample>();
+    services.AddTransient<AgentWithFileSkillExample>();
+    services.AddTransient<AgentWithFolderSkillExample>();
+    services.AddTransient<AgentWithCustomCodeSkillExample>();
+    services.AddTransient<AgentWithAllSkillsExample>();
+    services.AddTransient<AgentWithMcpFileWriterSkillExample>();
     services.AddTransient<ChatWithImageGenOpenAiExample>();
     services.AddTransient<ChatExampleGemini>();
     services.AddTransient<ChatGrammarExampleGemini>();
@@ -183,6 +195,11 @@ public class ExampleRegistry(IServiceProvider serviceProvider)
                 ("\u25a0 OpenAi Chat", serviceProvider.GetRequiredService<ChatExampleOpenAi>()),
                 ("\u25a0 OpenAi Chat with image", serviceProvider.GetRequiredService<ChatWithImageGenOpenAiExample>()),
                 ("\u25a0 OpenAi Agent with Web Data Source", serviceProvider.GetRequiredService<AgentWithWebDataSourceOpenAiExample>()),
+                ("\u25a0 Agent with Skills (file-based .md)", serviceProvider.GetRequiredService<AgentWithFileSkillExample>()),
+                ("\u25a0 Agent with Skills (folder-based SKILL.md)", serviceProvider.GetRequiredService<AgentWithFolderSkillExample>()),
+                ("\u25a0 Agent with Skills (custom C# skill)", serviceProvider.GetRequiredService<AgentWithCustomCodeSkillExample>()),
+                ("\u25a0 Agent with Skills (.WithAllSkills)", serviceProvider.GetRequiredService<AgentWithAllSkillsExample>()),
+                ("\u25a0 Agent with Skills (MCP file writer)", serviceProvider.GetRequiredService<AgentWithMcpFileWriterSkillExample>()),
                 ("\u25a0 Gemini Chat", serviceProvider.GetRequiredService<ChatExampleGemini>()),
                 ("\u25a0 Gemini Chat with grammar", serviceProvider.GetRequiredService<ChatGrammarExampleGemini>()),
                 ("\u25a0 Gemini Chat with image", serviceProvider.GetRequiredService<ChatWithImageGenGeminiExample>()),

Examples/Examples/appsettings.json

@@ -1,8 +1,10 @@
 {
   "Logging": {
     "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
+        "Default": "Information",
+        "Microsoft.AspNetCore": "Warning",
+        "System.Net.Http": "Warning",
+        "MaIN.Services.Services.SkillComposer": "Information"
     }
   },
   "MaIN": {

Examples/Examples/skills/code-review/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: code-review
+description: Reviews code for bugs, security issues, and improvements
+version: 1.0.0
+steps:
+  - ANSWER
+placement: before
+priority: 30
+tags:
+  - code
+  - review
+  - quality
+includes:
+  - prompts/review.md
+  - examples/bad.md
+  - examples/good.md
+---
+
+You are an expert code reviewer with deep knowledge of software engineering best practices.
+Keep reviews concise and actionable.