From 08d179b93dd2dcc13a7076f99b8104ec886d4cb6 Mon Sep 17 00:00:00 2001
From: SergeyMenshykh <SergeMenshikh@outlook.com>
Date: Mon, 22 Jun 2026 20:06:47 +0100
Subject: [PATCH 1/2] .NET: Explicitly emit available_resources and
 available_scripts in skill content

AgentInlineSkillContentBuilder now always emits <available_resources> and
<available_scripts> elements, using self-closing tags when a skill has no
resources or scripts. This signals to the model exactly what is callable so it
does not hallucinate non-existent resource or script names. Script parameter
schemas are wrapped in a nested <parameters_schema> element.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Skills/File/AgentFileSkill.cs             |   4 +-
 .../Skills/Programmatic/AgentClassSkill.cs    |  23 ++-
 .../Skills/Programmatic/AgentInlineSkill.cs   |  17 +-
 .../AgentInlineSkillContentBuilder.cs         |  50 +++--
 .../AgentSkills/AgentClassSkillTests.cs       |  15 +-
 .../AgentSkills/AgentFileSkillScriptTests.cs  |   8 +-
 .../AgentInlineSkillContentBuilderTests.cs    | 194 ++++++++++++++++++
 .../AgentSkills/AgentInlineSkillTests.cs      |  51 ++---
 8 files changed, 298 insertions(+), 64 deletions(-)
 create mode 100644 dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs

diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
index 8a74fa034e1..a86a0e98b3e 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
@@ -49,13 +49,13 @@ internal AgentFileSkill(
     /// <inheritdoc/>
     /// <remarks>
     /// Returns the raw SKILL.md content. When the skill has scripts, a
-    /// <c>&lt;script_schemas&gt;</c> block is appended describing the argument format.
+    /// <c>&lt;available_scripts&gt;</c> block is appended describing the argument format.
     /// The result is cached after the first access.
     /// </remarks>
     public override ValueTask<string> GetContentAsync(CancellationToken cancellationToken = default)
     {
         var content = this._content ??= this._scripts is { Count: > 0 }
-            ? this._originalContent + AgentInlineSkillContentBuilder.BuildScriptSchemasBlock(this._scripts)
+            ? this._originalContent + AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(this._scripts)
             : this._originalContent;
         return new(content);
     }
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
index 3572bff8268..75309d759c1 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
@@ -120,6 +120,7 @@ protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarsh
             this.Frontmatter.Name,
             this.Frontmatter.Description,
             this.Instructions,
+            this.Resources,
             this.Scripts));
     }
 
@@ -160,8 +161,9 @@ protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarsh
     /// Override this property in derived classes to provide skill-specific resources.
     /// </para>
     /// <para>
-    /// Resources are not automatically included in the skill body.
-    /// To enable discovery, reference resources by name in the skill's instructions or in other resources.
+    /// Resources are listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the LLM
+    /// knows which ones can be accessed. When empty, a self-closing element is emitted to prevent
+    /// hallucinated resource calls.
     /// </para>
     /// </remarks>
     public virtual IReadOnlyList<AgentSkillResource>? Resources => this._resources.Value;
@@ -178,8 +180,9 @@ protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarsh
     /// Override this property in derived classes to provide skill-specific scripts.
     /// </para>
     /// <para>
-    /// Only script parameter schemas are included in the skill body (as a <c>&lt;script_schemas&gt;</c> block).
-    /// To enable discovery, reference scripts by name in the skill's instructions or in a resource.
+    /// Scripts are listed in the <c>&lt;available_scripts&gt;</c> block of the skill body so the LLM
+    /// knows which ones can be called. When empty, a self-closing element is emitted to prevent
+    /// hallucinated script calls.
     /// </para>
     /// </remarks>
     public virtual IReadOnlyList<AgentSkillScript>? Scripts => this._scripts.Value;
@@ -202,8 +205,8 @@ protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarsh
     /// Creates a skill resource backed by a static value.
     /// </summary>
     /// <remarks>
-    /// Resources are not automatically included in the skill body.
-    /// To enable discovery, reference the resource by name in the skill's instructions or in another resource.
+    /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the LLM
+    /// knows it can be accessed; an empty block prevents hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="value">The static resource value.</param>
@@ -216,8 +219,8 @@ protected AgentSkillResource CreateResource(string name, object value, string? d
     /// Creates a skill resource backed by a delegate that produces a dynamic value.
     /// </summary>
     /// <remarks>
-    /// Resources are not automatically included in the skill body.
-    /// To enable discovery, reference the resource by name in the skill's instructions or in another resource.
+    /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the LLM
+    /// knows it can be accessed; an empty block prevents hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="method">A method that produces the resource value when requested.</param>
@@ -234,8 +237,8 @@ protected AgentSkillResource CreateResource(string name, Delegate method, string
     /// Creates a skill script backed by a delegate.
     /// </summary>
     /// <remarks>
-    /// Only the script's parameter schema is included in the skill body (as a <c>&lt;script_schemas&gt;</c> block).
-    /// To enable discovery, reference the script by name in the skill's instructions or in a resource.
+    /// The script is listed in the <c>&lt;available_scripts&gt;</c> block of the skill body so the LLM
+    /// knows it can be called; an empty block prevents hallucinated script calls.
     /// </remarks>
     /// <param name="name">The script name.</param>
     /// <param name="method">A method to execute when the script is invoked.</param>
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
index ce65777b8e9..7a5093830fe 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
@@ -107,7 +107,7 @@ public AgentInlineSkill(
     /// <inheritdoc/>
     public override ValueTask<string> GetContentAsync(CancellationToken cancellationToken = default)
     {
-        return new(this._cachedContent ??= AgentInlineSkillContentBuilder.Build(this.Frontmatter.Name, this.Frontmatter.Description, this._instructions, this._scripts));
+        return new(this._cachedContent ??= AgentInlineSkillContentBuilder.Build(this.Frontmatter.Name, this.Frontmatter.Description, this._instructions, this._resources, this._scripts));
     }
 
     /// <inheritdoc/>
@@ -128,8 +128,9 @@ public override ValueTask<string> GetContentAsync(CancellationToken cancellation
     /// Registers a static resource with this skill.
     /// </summary>
     /// <remarks>
-    /// Resources are not automatically included in the skill body.
-    /// To enable discovery, reference the resource by name in the skill's instructions or in another resource.
+    /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the
+    /// LLM knows it can be accessed. When no resources are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="value">The static resource value.</param>
@@ -146,8 +147,9 @@ public AgentInlineSkill AddResource(string name, object value, string? descripti
     /// The delegate's parameters and return type are automatically marshaled via <c>AIFunctionFactory</c>.
     /// </summary>
     /// <remarks>
-    /// Resources are not automatically included in the skill body.
-    /// To enable discovery, reference the resource by name in the skill's instructions or in another resource.
+    /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the
+    /// LLM knows it can be accessed. When no resources are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="method">A method that produces the resource value when requested.</param>
@@ -168,8 +170,9 @@ public AgentInlineSkill AddResource(string name, Delegate method, string? descri
     /// The delegate's parameters and return type are automatically marshaled via <c>AIFunctionFactory</c>.
     /// </summary>
     /// <remarks>
-    /// Only the script's parameter schema is included in the skill body (as a <c>&lt;script_schemas&gt;</c> block).
-    /// To enable discovery, reference the script by name in the skill's instructions or in a resource.
+    /// The script is listed in the <c>&lt;available_scripts&gt;</c> block of the skill body so the
+    /// LLM knows it can be called. When no scripts are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated script calls.
     /// </remarks>
     /// <param name="name">The script name.</param>
     /// <param name="method">A method to execute when the script is invoked.</param>
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
index d2f27edadc5..95fbb3ef400 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
@@ -12,17 +12,19 @@ namespace Microsoft.Agents.AI;
 internal static class AgentInlineSkillContentBuilder
 {
     /// <summary>
-    /// Builds the complete skill content containing name, description, instructions, and script parameter schemas.
+    /// Builds the complete skill content containing name, description, instructions, resources, and script parameter schemas.
     /// </summary>
     /// <param name="name">The skill name.</param>
     /// <param name="description">The skill description.</param>
     /// <param name="instructions">The raw instructions text.</param>
+    /// <param name="resources">Optional resources associated with the skill.</param>
     /// <param name="scripts">Optional scripts associated with the skill.</param>
     /// <returns>An XML-structured content string.</returns>
     public static string Build(
         string name,
         string description,
         string instructions,
+        IReadOnlyList<AgentSkillResource>? resources,
         IReadOnlyList<AgentSkillScript>? scripts)
     {
         _ = Throw.IfNullOrWhitespace(name);
@@ -37,24 +39,46 @@ public static string Build(
         .Append(EscapeXmlString(instructions))
         .Append("\n</instructions>");
 
+        if (resources is { Count: > 0 })
+        {
+            sb.Append("\n\n<available_resources>\n");
+            foreach (var resource in resources)
+            {
+                sb.Append($"  <resource name=\"{EscapeXmlString(resource.Name)}\"/>\n");
+            }
+
+            sb.Append("</available_resources>");
+        }
+        else
+        {
+            // Emit an empty element so the model knows no resources are available and does not hallucinate resource names.
+            sb.Append("\n\n<available_resources />");
+        }
+
         if (scripts is { Count: > 0 })
         {
             sb.Append('\n');
-            sb.Append(BuildScriptSchemasBlock(scripts));
+            sb.Append(BuildAvailableScriptsBlock(scripts));
+        }
+        else
+        {
+            // Emit an empty element so the model knows no scripts are available and does not hallucinate script names.
+            sb.Append("\n\n<available_scripts />");
         }
 
         return sb.ToString();
     }
 
     /// <summary>
-    /// Builds a <c>&lt;script_schemas&gt;...&lt;/script_schemas&gt;</c> XML block for the given scripts.
-    /// Each script is emitted as a <c>&lt;schema script="..."&gt;</c> element containing only
-    /// the parameter schema. This block serves as a reference for the model to know how to
-    /// format arguments when calling scripts, not as a discovery mechanism.
+    /// Builds an <c>&lt;available_scripts&gt;...&lt;/available_scripts&gt;</c> XML block for the given scripts.
+    /// Each script is emitted as a <c>&lt;script name="..."&gt;</c> element; when the script has a
+    /// parameter schema it is wrapped in a nested <c>&lt;parameters_schema&gt;</c> element, otherwise a
+    /// self-closing <c>&lt;script&gt;</c> element is used. This block lets the model know which scripts
+    /// can be called and how to format their arguments.
     /// </summary>
     /// <param name="scripts">The scripts to include in the block.</param>
-    /// <returns>An XML string starting with <c>\n&lt;script_schemas&gt;</c>, or an empty string if the list is empty.</returns>
-    public static string BuildScriptSchemasBlock(IReadOnlyList<AgentSkillScript> scripts)
+    /// <returns>An XML string starting with <c>\n&lt;available_scripts&gt;</c>, or an empty string if the list is empty.</returns>
+    public static string BuildAvailableScriptsBlock(IReadOnlyList<AgentSkillScript> scripts)
     {
         _ = Throw.IfNull(scripts);
 
@@ -64,7 +88,7 @@ public static string BuildScriptSchemasBlock(IReadOnlyList<AgentSkillScript> scr
         }
 
         var sb = new StringBuilder();
-        sb.Append("\n<script_schemas>\n");
+        sb.Append("\n<available_scripts>\n");
 
         foreach (var script in scripts)
         {
@@ -72,15 +96,17 @@ public static string BuildScriptSchemasBlock(IReadOnlyList<AgentSkillScript> scr
 
             if (parametersSchema is null)
             {
-                sb.Append($"  <schema script=\"{EscapeXmlString(script.Name)}\"/>\n");
+                sb.Append($"  <script name=\"{EscapeXmlString(script.Name)}\"/>\n");
             }
             else
             {
-                sb.Append($"  <schema script=\"{EscapeXmlString(script.Name)}\">{EscapeXmlString(parametersSchema.Value.GetRawText(), preserveQuotes: true)}</schema>\n");
+                sb.Append($"  <script name=\"{EscapeXmlString(script.Name)}\">\n");
+                sb.Append($"    <parameters_schema>{EscapeXmlString(parametersSchema.Value.GetRawText(), preserveQuotes: true)}</parameters_schema>\n");
+                sb.Append("  </script>\n");
             }
         }
 
-        sb.Append("</script_schemas>");
+        sb.Append("</available_scripts>");
 
         return sb.ToString();
     }
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentClassSkillTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentClassSkillTests.cs
index 17bf71a3886..5fd1fa77bab 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentClassSkillTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentClassSkillTests.cs
@@ -382,9 +382,10 @@ public async Task AttributedFullSkill_IncludesContentWithSchema_AndCachesMembers
         // Arrange
         var skill = new AttributedFullSkill();
 
-        // Act & Assert — Content no longer includes resources in body; scripts are in script_schemas
-        Assert.DoesNotContain("<resources>", await skill.GetContentAsync());
-        Assert.Contains("<script_schemas>", await skill.GetContentAsync());
+        // Act & Assert — Content includes resources in body; scripts are in available_scripts
+        Assert.Contains("<available_resources>", await skill.GetContentAsync());
+        Assert.Contains("conversion-table", await skill.GetContentAsync());
+        Assert.Contains("<available_scripts>", await skill.GetContentAsync());
         Assert.Contains("convert", await skill.GetContentAsync());
 
         // Act & Assert — discovered members are cached
@@ -502,7 +503,7 @@ public async Task SerializerOptions_UsedForReflectedMembersAsync()
     }
 
     [Fact]
-    public async Task Content_DoesNotRenderResources_InBodyAsync()
+    public async Task Content_RendersResources_InBodyAsync()
     {
         // Arrange
         var skill = new AttributedResourcePropertiesSkill();
@@ -510,8 +511,10 @@ public async Task Content_DoesNotRenderResources_InBodyAsync()
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — resources are no longer rendered in body content
-        Assert.DoesNotContain("<resources>", content);
+        // Assert — resources are rendered in body content by name; descriptions are not emitted
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("ref-data", content);
+        Assert.DoesNotContain("Some important data.", content);
     }
 
     [Fact]
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
index aa001fd2a0c..6767b8f0f05 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
@@ -122,10 +122,10 @@ public async Task Content_WithScripts_AppendsPerScriptEntriesAsync()
 
         // Assert — content starts with original and appends per-script entries
         Assert.StartsWith("Original content", content);
-        Assert.Contains("<script_schemas>", content);
-        Assert.Contains("<schema script=\"build\">", content);
-        Assert.Contains("<schema script=\"deploy\">", content);
-        Assert.Contains("</script_schemas>", content);
+        Assert.Contains("<available_scripts>", content);
+        Assert.Contains("<script name=\"build\">", content);
+        Assert.Contains("<script name=\"deploy\">", content);
+        Assert.Contains("</available_scripts>", content);
     }
 
     [Fact]
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs
new file mode 100644
index 00000000000..6512b846741
--- /dev/null
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs
@@ -0,0 +1,194 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Agents.AI.UnitTests.AgentSkills;
+
+/// <summary>
+/// Unit tests for <see cref="AgentInlineSkillContentBuilder"/>, focusing on the structure of the
+/// emitted <c>&lt;available_resources&gt;</c> and <c>&lt;available_scripts&gt;</c> blocks.
+/// </summary>
+public sealed class AgentInlineSkillContentBuilderTests
+{
+    [Fact]
+    public void Build_NullResourcesAndScripts_EmitsSelfClosingTags()
+    {
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build("my-skill", "A skill.", "Instructions.", resources: null, scripts: null);
+
+        // Assert — explicit empty elements signal "none available" so the model does not hallucinate names
+        Assert.Contains("<available_resources />", content);
+        Assert.Contains("<available_scripts />", content);
+        Assert.DoesNotContain("<available_resources>", content);
+        Assert.DoesNotContain("<available_scripts>", content);
+    }
+
+    [Fact]
+    public void Build_EmptyResourcesAndScripts_EmitsSelfClosingTags()
+    {
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build(
+            "my-skill",
+            "A skill.",
+            "Instructions.",
+            resources: Array.Empty<AgentSkillResource>(),
+            scripts: Array.Empty<AgentSkillScript>());
+
+        // Assert
+        Assert.Contains("<available_resources />", content);
+        Assert.Contains("<available_scripts />", content);
+    }
+
+    [Fact]
+    public void Build_ResourcesOnly_EmitsResourceEntriesAndSelfClosingScripts()
+    {
+        // Arrange
+        var resources = new AgentSkillResource[]
+        {
+            new AgentInlineSkillResource("config", "value", "A described resource."),
+            new AgentInlineSkillResource("table", "value"),
+        };
+
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build("my-skill", "A skill.", "Instructions.", resources, scripts: null);
+
+        // Assert — resources are listed by name (no description), scripts are an empty element
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("<resource name=\"config\"/>", content);
+        Assert.Contains("<resource name=\"table\"/>", content);
+        Assert.Contains("</available_resources>", content);
+        Assert.DoesNotContain("A described resource.", content);
+        Assert.Contains("<available_scripts />", content);
+    }
+
+    [Fact]
+    public void Build_ScriptsOnly_EmitsSelfClosingResourcesAndScriptsBlock()
+    {
+        // Arrange
+        var scripts = new AgentSkillScript[] { new FakeScript("run", ParseSchema("{\"type\":\"object\"}")) };
+
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build("my-skill", "A skill.", "Instructions.", resources: null, scripts);
+
+        // Assert
+        Assert.Contains("<available_resources />", content);
+        Assert.Contains("<available_scripts>", content);
+        Assert.Contains("<script name=\"run\">", content);
+        Assert.Contains("</available_scripts>", content);
+    }
+
+    [Fact]
+    public void Build_MultipleResources_RendersAllInRegistrationOrder()
+    {
+        // Arrange
+        var resources = new AgentSkillResource[]
+        {
+            new AgentInlineSkillResource("first", "v"),
+            new AgentInlineSkillResource("second", "v"),
+            new AgentInlineSkillResource("third", "v"),
+        };
+
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build("my-skill", "A skill.", "Instructions.", resources, scripts: null);
+
+        // Assert — order is preserved
+        var firstIndex = content.IndexOf("first", StringComparison.Ordinal);
+        var secondIndex = content.IndexOf("second", StringComparison.Ordinal);
+        var thirdIndex = content.IndexOf("third", StringComparison.Ordinal);
+        Assert.True(firstIndex < secondIndex && secondIndex < thirdIndex);
+    }
+
+    [Fact]
+    public void Build_ResourceNameWithSpecialCharacters_IsXmlEscaped()
+    {
+        // Arrange
+        var resources = new AgentSkillResource[] { new AgentInlineSkillResource("a<b>&\"c", "v") };
+
+        // Act
+        var content = AgentInlineSkillContentBuilder.Build("my-skill", "A skill.", "Instructions.", resources, scripts: null);
+
+        // Assert — XML special characters in the name are escaped
+        Assert.Contains("<resource name=\"a&lt;b&gt;&amp;&quot;c\"/>", content);
+    }
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_EmptyList_ReturnsEmptyString()
+    {
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(Array.Empty<AgentSkillScript>());
+
+        // Assert
+        Assert.Equal(string.Empty, block);
+    }
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_ScriptWithoutSchema_UsesSelfClosingScript()
+    {
+        // Arrange — a script whose ParametersSchema is null
+        var scripts = new AgentSkillScript[] { new FakeScript("no-params", parametersSchema: null) };
+
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(scripts);
+
+        // Assert — self-closing <script> element with no nested parameters_schema
+        Assert.Contains("<script name=\"no-params\"/>", block);
+        Assert.DoesNotContain("<parameters_schema>", block);
+    }
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_ScriptWithSchema_WrapsSchemaInParametersSchemaElement()
+    {
+        // Arrange
+        var scripts = new AgentSkillScript[] { new FakeScript("search", ParseSchema("{\"type\":\"object\",\"properties\":{\"query\":{\"type\":\"string\"}}}")) };
+
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(scripts);
+
+        // Assert — schema is wrapped in <parameters_schema> with preserved quotes (no CDATA)
+        Assert.Contains("<script name=\"search\">", block);
+        Assert.Contains("<parameters_schema>", block);
+        Assert.Contains("\"query\"", block);
+        Assert.Contains("</parameters_schema>", block);
+        Assert.Contains("</script>", block);
+        Assert.DoesNotContain("<![CDATA[", block);
+    }
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_ScriptNameWithSpecialCharacters_IsXmlEscaped()
+    {
+        // Arrange
+        var scripts = new AgentSkillScript[] { new FakeScript("a<b>&\"c", parametersSchema: null) };
+
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(scripts);
+
+        // Assert
+        Assert.Contains("<script name=\"a&lt;b&gt;&amp;&quot;c\"/>", block);
+    }
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_NullScripts_Throws() =>
+        Assert.Throws<ArgumentNullException>(() => AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(null!));
+
+    private static JsonElement ParseSchema(string json) => JsonDocument.Parse(json).RootElement.Clone();
+
+    private sealed class FakeScript : AgentSkillScript
+    {
+        private readonly JsonElement? _parametersSchema;
+
+        public FakeScript(string name, JsonElement? parametersSchema)
+            : base(name)
+        {
+            this._parametersSchema = parametersSchema;
+        }
+
+        public override JsonElement? ParametersSchema => this._parametersSchema;
+
+        public override Task<object?> RunAsync(AgentSkill skill, JsonElement? arguments, IServiceProvider? serviceProvider, CancellationToken cancellationToken = default) =>
+            Task.FromResult<object?>(null);
+    }
+}
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
index d5b04d56530..b8b1736457d 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
@@ -149,7 +149,7 @@ public async Task Content_IsCachedAcrossAccessesAsync()
     }
 
     [Fact]
-    public async Task Content_DoesNotIncludeResourcesInBodyAsync()
+    public async Task Content_IncludesResourcesInBodyAsync()
     {
         // Arrange
         var skill = new AgentInlineSkill("my-skill", "A valid skill.", "Instructions.");
@@ -158,12 +158,14 @@ public async Task Content_DoesNotIncludeResourcesInBodyAsync()
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — resources are no longer rendered in the body; they're accessed via GetResourceAsync
-        Assert.DoesNotContain("<resources>", content);
+        // Assert — resources are rendered in the body so the model can discover them
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("config", content);
+        Assert.DoesNotContain("A config resource.", content);
     }
 
     [Fact]
-    public async Task Content_DoesNotIncludeDelegateResourcesInBodyAsync()
+    public async Task Content_IncludesDelegateResourcesInBodyAsync()
     {
         // Arrange
         var skill = new AgentInlineSkill("my-skill", "A valid skill.", "Instructions.");
@@ -172,8 +174,9 @@ public async Task Content_DoesNotIncludeDelegateResourcesInBodyAsync()
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — resources are no longer rendered in the body
-        Assert.DoesNotContain("<resources>", content);
+        // Assert — resources are rendered in the body
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("dynamic", content);
     }
 
     [Fact]
@@ -187,7 +190,7 @@ public async Task Content_IncludesScriptsAddedBeforeFirstAccessAsync()
         var content = await skill.GetContentAsync();
 
         // Assert
-        Assert.Contains("<script_schemas>", content);
+        Assert.Contains("<available_scripts>", content);
         Assert.Contains("run", content);
     }
 
@@ -218,8 +221,9 @@ public async Task Content_IncludesScriptSchemasAddedBeforeFirstAccessAsync()
         var content = await skill.GetContentAsync();
 
         // Assert
-        Assert.DoesNotContain("<resources>", content);
-        Assert.Contains("<script_schemas>", content);
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("r1", content);
+        Assert.Contains("<available_scripts>", content);
         Assert.Contains("s1", content);
     }
 
@@ -233,8 +237,9 @@ public async Task Content_ParametersSchema_IsXmlEscapedAsync()
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — JSON schema should be present inside <schema> element (no extra wrapper) with preserved quotes
-        Assert.Contains("<schema script=\"search\">", content);
+        // Assert — JSON schema should be present inside <parameters_schema> element with preserved quotes
+        Assert.Contains("<script name=\"search\">", content);
+        Assert.Contains("<parameters_schema>", content);
         Assert.Contains("\"query\"", content);
         Assert.DoesNotContain("<![CDATA[", content);
     }
@@ -417,7 +422,7 @@ public void AddScript_ReturnsSameInstance_ForChaining()
     }
 
     [Fact]
-    public async Task Content_NoResourcesOrScripts_DoesNotContainResourcesOrScriptsTagsAsync()
+    public async Task Content_NoResourcesOrScripts_EmitsSelfClosingTagsAsync()
     {
         // Arrange
         var skill = new AgentInlineSkill("my-skill", "A valid skill.", "Instructions.");
@@ -425,9 +430,9 @@ public async Task Content_NoResourcesOrScripts_DoesNotContainResourcesOrScriptsT
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert
-        Assert.DoesNotContain("<resources>", content);
-        Assert.DoesNotContain("<script_schemas>", content);
+        // Assert — empty self-closing elements are emitted when no resources or scripts exist
+        Assert.Contains("<available_resources />", content);
+        Assert.Contains("<available_scripts />", content);
     }
 
     [Fact]
@@ -470,9 +475,8 @@ public async Task Content_ScriptWithDescription_DoesNotEmitDescriptionAttributeA
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — description is no longer emitted in the script_schemas block;
-        // the block only contains parameter schemas for calling scripts.
-        Assert.Contains("<schema script=\"my-script\"", content);
+        // Assert — only the script name is emitted; the description is not rendered as an attribute
+        Assert.Contains("<script name=\"my-script\"", content);
         Assert.DoesNotContain("description=\"Runs something.\"", content);
     }
 
@@ -492,7 +496,7 @@ public async Task Content_ScriptWithoutParametersOrDescription_UsesSelfClosingTa
     }
 
     [Fact]
-    public async Task Content_ResourceWithDescription_NotRenderedInBodyAsync()
+    public async Task Content_ResourceWithDescription_RenderedInBodyWithoutDescriptionAsync()
     {
         // Arrange
         var skill = new AgentInlineSkill("my-skill", "A valid skill.", "Instructions.");
@@ -502,10 +506,11 @@ public async Task Content_ResourceWithDescription_NotRenderedInBodyAsync()
         // Act
         var content = await skill.GetContentAsync();
 
-        // Assert — resources are no longer rendered in the body
-        Assert.DoesNotContain("<resources>", content);
-        Assert.DoesNotContain("with-desc", content);
-        Assert.DoesNotContain("no-desc", content);
+        // Assert — resources are rendered by name in the body; descriptions are not emitted
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("<resource name=\"with-desc\"/>", content);
+        Assert.Contains("<resource name=\"no-desc\"/>", content);
+        Assert.DoesNotContain("A described resource.", content);
     }
 
     [Fact]

From bb7fdc8b61f6be4f91bda1c8a055f4ed77b7d9f3 Mon Sep 17 00:00:00 2001
From: SergeyMenshykh <SergeMenshikh@outlook.com>
Date: Mon, 22 Jun 2026 20:56:39 +0100
Subject: [PATCH 2/2] .NET: Emit available_resources block for file-backed
 skills

Align AgentFileSkill with inline/class skills by surfacing discovered
resources in the loaded skill content. AgentFileSkill.GetContentAsync now
appends an <available_resources> block (before <available_scripts>) listing
resource names so the model has an authoritative list and does not
hallucinate resource names. Extracted a reusable BuildAvailableResourcesBlock
helper in AgentInlineSkillContentBuilder.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Skills/File/AgentFileSkill.cs             | 17 +++---
 .../Skills/Programmatic/AgentClassSkill.cs    |  9 ++-
 .../AgentInlineSkillContentBuilder.cs         | 61 ++++++++++++-------
 .../AgentSkills/AgentFileSkillScriptTests.cs  | 57 ++++++++++++++++-
 .../AgentInlineSkillContentBuilderTests.cs    | 55 +++++++++++++++--
 .../AgentSkills/AgentInlineSkillTests.cs      |  6 +-
 6 files changed, 162 insertions(+), 43 deletions(-)

diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
index a86a0e98b3e..36636a4a851 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/File/AgentFileSkill.cs
@@ -48,16 +48,19 @@ internal AgentFileSkill(
 
     /// <inheritdoc/>
     /// <remarks>
-    /// Returns the raw SKILL.md content. When the skill has scripts, a
-    /// <c>&lt;available_scripts&gt;</c> block is appended describing the argument format.
-    /// The result is cached after the first access.
+    /// Returns the raw SKILL.md content with an <c>&lt;available_resources&gt;</c> and an
+    /// <c>&lt;available_scripts&gt;</c> block appended, so the model gets an authoritative list for each
+    /// category. A category with no entries is appended as a self-closing element (e.g.
+    /// <c>&lt;available_scripts /&gt;</c>) so the model knows none are available and does not hallucinate
+    /// their names. The result is cached after the first access.
     /// </remarks>
     public override ValueTask<string> GetContentAsync(CancellationToken cancellationToken = default)
     {
-        var content = this._content ??= this._scripts is { Count: > 0 }
-            ? this._originalContent + AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(this._scripts)
-            : this._originalContent;
-        return new(content);
+        this._content ??=
+            this._originalContent
+            + "\n" + AgentInlineSkillContentBuilder.BuildAvailableResourcesBlock(this._resources)
+            + "\n" + AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(this._scripts);
+        return new(this._content);
     }
 
     /// <summary>
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
index 75309d759c1..03bae591565 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
@@ -206,7 +206,8 @@ protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarsh
     /// </summary>
     /// <remarks>
     /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the LLM
-    /// knows it can be accessed; an empty block prevents hallucinated resource calls.
+    /// knows it can be accessed. When no resources are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="value">The static resource value.</param>
@@ -220,7 +221,8 @@ protected AgentSkillResource CreateResource(string name, object value, string? d
     /// </summary>
     /// <remarks>
     /// The resource is listed in the <c>&lt;available_resources&gt;</c> block of the skill body so the LLM
-    /// knows it can be accessed; an empty block prevents hallucinated resource calls.
+    /// knows it can be accessed. When no resources are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated resource calls.
     /// </remarks>
     /// <param name="name">The resource name.</param>
     /// <param name="method">A method that produces the resource value when requested.</param>
@@ -238,7 +240,8 @@ protected AgentSkillResource CreateResource(string name, Delegate method, string
     /// </summary>
     /// <remarks>
     /// The script is listed in the <c>&lt;available_scripts&gt;</c> block of the skill body so the LLM
-    /// knows it can be called; an empty block prevents hallucinated script calls.
+    /// knows it can be called. When no scripts are registered, the block is emitted as a
+    /// self-closing element to signal that none exist, preventing hallucinated script calls.
     /// </remarks>
     /// <param name="name">The script name.</param>
     /// <param name="method">A method to execute when the script is invoked.</param>
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
index 95fbb3ef400..bae35766856 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillContentBuilder.cs
@@ -39,33 +39,44 @@ public static string Build(
         .Append(EscapeXmlString(instructions))
         .Append("\n</instructions>");
 
-        if (resources is { Count: > 0 })
-        {
-            sb.Append("\n\n<available_resources>\n");
-            foreach (var resource in resources)
-            {
-                sb.Append($"  <resource name=\"{EscapeXmlString(resource.Name)}\"/>\n");
-            }
+        sb.Append('\n');
+        sb.Append(BuildAvailableResourcesBlock(resources ?? []));
+        sb.Append('\n');
+        sb.Append(BuildAvailableScriptsBlock(scripts ?? []));
 
-            sb.Append("</available_resources>");
-        }
-        else
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Builds an <c>&lt;available_resources&gt;...&lt;/available_resources&gt;</c> XML block for the given resources.
+    /// Each resource is emitted as a self-closing <c>&lt;resource name="..."/&gt;</c> element. When the list is empty,
+    /// a self-closing <c>&lt;available_resources /&gt;</c> element is returned. This block lets the model know which
+    /// resources can be read (or that there are none) so it does not hallucinate resource names.
+    /// </summary>
+    /// <param name="resources">The resources to include in the block.</param>
+    /// <returns>
+    /// An XML string starting with <c>\n&lt;available_resources&gt;</c>, or <c>\n&lt;available_resources /&gt;</c> if the list is empty.
+    /// </returns>
+    public static string BuildAvailableResourcesBlock(IReadOnlyList<AgentSkillResource> resources)
+    {
+        _ = Throw.IfNull(resources);
+
+        if (resources.Count == 0)
         {
             // Emit an empty element so the model knows no resources are available and does not hallucinate resource names.
-            sb.Append("\n\n<available_resources />");
+            return "\n<available_resources />";
         }
 
-        if (scripts is { Count: > 0 })
-        {
-            sb.Append('\n');
-            sb.Append(BuildAvailableScriptsBlock(scripts));
-        }
-        else
+        var sb = new StringBuilder();
+        sb.Append("\n<available_resources>\n");
+
+        foreach (var resource in resources)
         {
-            // Emit an empty element so the model knows no scripts are available and does not hallucinate script names.
-            sb.Append("\n\n<available_scripts />");
+            sb.Append($"  <resource name=\"{EscapeXmlString(resource.Name)}\"/>\n");
         }
 
+        sb.Append("</available_resources>");
+
         return sb.ToString();
     }
 
@@ -73,18 +84,22 @@ public static string Build(
     /// Builds an <c>&lt;available_scripts&gt;...&lt;/available_scripts&gt;</c> XML block for the given scripts.
     /// Each script is emitted as a <c>&lt;script name="..."&gt;</c> element; when the script has a
     /// parameter schema it is wrapped in a nested <c>&lt;parameters_schema&gt;</c> element, otherwise a
-    /// self-closing <c>&lt;script&gt;</c> element is used. This block lets the model know which scripts
-    /// can be called and how to format their arguments.
+    /// self-closing <c>&lt;script&gt;</c> element is used. When the list is empty, a self-closing
+    /// <c>&lt;available_scripts /&gt;</c> element is returned. This block lets the model know which scripts
+    /// can be called and how to format their arguments (or that there are none) so it does not hallucinate script names.
     /// </summary>
     /// <param name="scripts">The scripts to include in the block.</param>
-    /// <returns>An XML string starting with <c>\n&lt;available_scripts&gt;</c>, or an empty string if the list is empty.</returns>
+    /// <returns>
+    /// An XML string starting with <c>\n&lt;available_scripts&gt;</c>, or <c>\n&lt;available_scripts /&gt;</c> if the list is empty.
+    /// </returns>
     public static string BuildAvailableScriptsBlock(IReadOnlyList<AgentSkillScript> scripts)
     {
         _ = Throw.IfNull(scripts);
 
         if (scripts.Count == 0)
         {
-            return string.Empty;
+            // Emit an empty element so the model knows no scripts are available and does not hallucinate script names.
+            return "\n<available_scripts />";
         }
 
         var sb = new StringBuilder();
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
index 6767b8f0f05..0957ee0622e 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentFileSkillScriptTests.cs
@@ -126,10 +126,13 @@ public async Task Content_WithScripts_AppendsPerScriptEntriesAsync()
         Assert.Contains("<script name=\"build\">", content);
         Assert.Contains("<script name=\"deploy\">", content);
         Assert.Contains("</available_scripts>", content);
+
+        // A scripts-only skill still emits an empty resources peer so the model knows none are available
+        Assert.Contains("<available_resources />", content);
     }
 
     [Fact]
-    public async Task Content_WithoutScripts_ReturnsOriginalContentAsync()
+    public async Task Content_WithoutResourcesOrScripts_EmitsSelfClosingPeersAsync()
     {
         // Arrange
         var fileSkill = new AgentFileSkill(
@@ -140,8 +143,56 @@ public async Task Content_WithoutScripts_ReturnsOriginalContentAsync()
         // Act
         var content = await fileSkill.GetContentAsync();
 
-        // Assert
-        Assert.Equal("Original content only", content);
+        // Assert — both blocks are always emitted as self-closing elements so the model knows none are available
+        Assert.StartsWith("Original content only", content);
+        Assert.Contains("<available_resources />", content);
+        Assert.Contains("<available_scripts />", content);
+    }
+
+    [Fact]
+    public async Task Content_WithResources_AppendsResourceEntriesAsync()
+    {
+        // Arrange
+        var fileSkill = new AgentFileSkill(
+            new AgentSkillFrontmatter("my-skill", "A skill"),
+            "Original content",
+            "/skills/my-skill",
+            resources: [new AgentInlineSkillResource("reference", "value"), new AgentInlineSkillResource("table", "value")]);
+
+        // Act
+        var content = await fileSkill.GetContentAsync();
+
+        // Assert — content starts with original and appends per-resource entries so the model knows what is callable
+        Assert.StartsWith("Original content", content);
+        Assert.Contains("<available_resources>", content);
+        Assert.Contains("<resource name=\"reference\"/>", content);
+        Assert.Contains("<resource name=\"table\"/>", content);
+        Assert.Contains("</available_resources>", content);
+
+        // A resources-only skill still emits an empty scripts peer so the model knows none are available
+        Assert.Contains("<available_scripts />", content);
+    }
+
+    [Fact]
+    public async Task Content_WithResourcesAndScripts_AppendsResourcesBeforeScriptsAsync()
+    {
+        // Arrange
+        static Task<object?> RunnerAsync(AgentFileSkill s, AgentFileSkillScript sc, JsonElement? a, IServiceProvider? sp, CancellationToken ct) => Task.FromResult<object?>(null);
+        var fileSkill = new AgentFileSkill(
+            new AgentSkillFrontmatter("my-skill", "A skill"),
+            "Original content",
+            "/skills/my-skill",
+            resources: [new AgentInlineSkillResource("reference", "value")],
+            scripts: [CreateScript("build", "/scripts/build.sh", RunnerAsync)]);
+
+        // Act
+        var content = await fileSkill.GetContentAsync();
+
+        // Assert — resources block precedes scripts block
+        var resourcesIndex = content.IndexOf("<available_resources>", StringComparison.Ordinal);
+        var scriptsIndex = content.IndexOf("<available_scripts>", StringComparison.Ordinal);
+        Assert.True(resourcesIndex >= 0 && scriptsIndex >= 0);
+        Assert.True(resourcesIndex < scriptsIndex);
     }
 
     [Fact]
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs
index 6512b846741..df9242abb80 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillContentBuilderTests.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
@@ -116,13 +115,61 @@ public void Build_ResourceNameWithSpecialCharacters_IsXmlEscaped()
     }
 
     [Fact]
-    public void BuildAvailableScriptsBlock_EmptyList_ReturnsEmptyString()
+    public void BuildAvailableResourcesBlock_EmptyList_ReturnsSelfClosingElement()
     {
         // Act
-        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(Array.Empty<AgentSkillScript>());
+        var block = AgentInlineSkillContentBuilder.BuildAvailableResourcesBlock(Array.Empty<AgentSkillResource>());
+
+        // Assert — empty list yields a self-closing element so the model knows none are available
+        Assert.Equal("\n<available_resources />", block);
+    }
+
+    [Fact]
+    public void BuildAvailableResourcesBlock_WithResources_EmitsSelfClosingResourceEntries()
+    {
+        // Arrange
+        var resources = new AgentSkillResource[]
+        {
+            new AgentInlineSkillResource("config", "value", "A described resource."),
+            new AgentInlineSkillResource("table", "value"),
+        };
+
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableResourcesBlock(resources);
+
+        // Assert — resources are listed by name only (no description)
+        Assert.Contains("<available_resources>", block);
+        Assert.Contains("<resource name=\"config\"/>", block);
+        Assert.Contains("<resource name=\"table\"/>", block);
+        Assert.Contains("</available_resources>", block);
+        Assert.DoesNotContain("A described resource.", block);
+    }
+
+    [Fact]
+    public void BuildAvailableResourcesBlock_ResourceNameWithSpecialCharacters_IsXmlEscaped()
+    {
+        // Arrange
+        var resources = new AgentSkillResource[] { new AgentInlineSkillResource("a<b>&\"c", "v") };
+
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableResourcesBlock(resources);
 
         // Assert
-        Assert.Equal(string.Empty, block);
+        Assert.Contains("<resource name=\"a&lt;b&gt;&amp;&quot;c\"/>", block);
+    }
+
+    [Fact]
+    public void BuildAvailableResourcesBlock_NullResources_Throws() =>
+        Assert.Throws<ArgumentNullException>(() => AgentInlineSkillContentBuilder.BuildAvailableResourcesBlock(null!));
+
+    [Fact]
+    public void BuildAvailableScriptsBlock_EmptyList_ReturnsSelfClosingElement()
+    {
+        // Act
+        var block = AgentInlineSkillContentBuilder.BuildAvailableScriptsBlock(Array.Empty<AgentSkillScript>());
+
+        // Assert — empty list yields a self-closing element so the model knows none are available
+        Assert.Equal("\n<available_scripts />", block);
     }
 
     [Fact]
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
index b8b1736457d..70b575a8bcc 100644
--- a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/AgentInlineSkillTests.cs
@@ -160,7 +160,7 @@ public async Task Content_IncludesResourcesInBodyAsync()
 
         // Assert — resources are rendered in the body so the model can discover them
         Assert.Contains("<available_resources>", content);
-        Assert.Contains("config", content);
+        Assert.Contains("<resource name=\"config\"/>", content);
         Assert.DoesNotContain("A config resource.", content);
     }
 
@@ -176,7 +176,7 @@ public async Task Content_IncludesDelegateResourcesInBodyAsync()
 
         // Assert — resources are rendered in the body
         Assert.Contains("<available_resources>", content);
-        Assert.Contains("dynamic", content);
+        Assert.Contains("<resource name=\"dynamic\"/>", content);
     }
 
     [Fact]
@@ -191,7 +191,7 @@ public async Task Content_IncludesScriptsAddedBeforeFirstAccessAsync()
 
         // Assert
         Assert.Contains("<available_scripts>", content);
-        Assert.Contains("run", content);
+        Assert.Contains("<script name=\"run\"", content);
     }
 
     [Fact]