diff --git a/dotnet/src/Microsoft.Agents.AI.AzureAI.Persistent/AgentsClientExtensions.cs b/dotnet/src/Microsoft.Agents.AI.AzureAI.Persistent/AgentsClientExtensions.cs
index b1b92ee3be..48a2485bbf 100644
--- a/dotnet/src/Microsoft.Agents.AI.AzureAI.Persistent/AgentsClientExtensions.cs
+++ b/dotnet/src/Microsoft.Agents.AI.AzureAI.Persistent/AgentsClientExtensions.cs
@@ -119,6 +119,7 @@ public static class AgentsClientExtensions
             tools,
             clientFactory,
             openAIClientOptions,
+            requireInvocableTools: true,
             cancellationToken);
     }
 
@@ -130,6 +131,10 @@ public static class AgentsClientExtensions
     /// <param name="tools">The tools to use when interacting with the agent. This is required when using prompt agent definitions with tools.</param>
     /// <param name="clientFactory">Provides a way to customize the creation of the underlying <see cref="IChatClient"/> used by the agent.</param>
     /// <param name="openAIClientOptions">An optional <see cref="OpenAIClientOptions"/> for configuring the underlying OpenAI client.</param>
+    /// <param name="requireInvocableTools">
+    /// This defaults to <see langword="true" /> and indicates whether to enforce the presence of invocable tools when the AIAgent is created with an agent definition that uses them.
+    /// Setting this to <see langword="false" /> will require manual handling of in-proc tool invocations by the caller.
+    /// </param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A <see cref="ChatClientAgent"/> instance that can be used to perform operations based on the provided version of the Azure AI Agent.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="agentsClient"/> or <paramref name="agentVersion"/> is <see langword="null"/>.</exception>
@@ -140,6 +145,7 @@ public static class AgentsClientExtensions
         IList<AITool>? tools = null,
         Func<IChatClient, IChatClient>? clientFactory = null,
         OpenAIClientOptions? openAIClientOptions = null,
+        bool requireInvocableTools = true,
         CancellationToken cancellationToken = default)
     {
         Throw.IfNull(agentsClient);
@@ -147,16 +153,13 @@ public static class AgentsClientExtensions
 
         ValidateUsingToolsParameter(agentVersion, tools);
 
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
-
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        var agentOptions = CreateChatClientAgentOptions(agentVersion, tools);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            tools,
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools);
     }
 
     /// <summary>
@@ -189,18 +192,15 @@ public static class AgentsClientExtensions
 
         var agentVersion = agentRecord.Versions.Latest;
 
-        ValidateUsingToolsParameter(agentVersion, options.ChatOptions?.Tools);
+        var agentOptions = CreateChatClientAgentOptions(agentVersion, options, requireInvocableTools: true);
 
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
-
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, options);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            agentOptions,
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools: true);
     }
 
     /// <summary>
@@ -233,18 +233,15 @@ public static class AgentsClientExtensions
 
         var agentVersion = agentRecord.Versions.Latest;
 
-        ValidateUsingToolsParameter(agentVersion, options.ChatOptions?.Tools);
+        var agentOptions = CreateChatClientAgentOptions(agentVersion, options, requireInvocableTools: true);
 
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
-
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, options);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            agentOptions,
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools: true);
     }
 
     /// <summary>
@@ -287,6 +284,7 @@ public static class AgentsClientExtensions
             creationOptions,
             clientFactory,
             openAIClientOptions,
+            requireInvocableTools: true,
             cancellationToken);
     }
 
@@ -330,6 +328,7 @@ public static class AgentsClientExtensions
             creationOptions,
             clientFactory,
             openAIClientOptions,
+            requireInvocableTools: true,
             cancellationToken);
     }
 
@@ -356,6 +355,7 @@ public static class AgentsClientExtensions
         Throw.IfNull(agentsClient);
         Throw.IfNull(options);
         Throw.IfNullOrWhitespace(model);
+        const bool RequireInvocableTools = true;
 
         if (string.IsNullOrWhiteSpace(options.Name))
         {
@@ -367,7 +367,7 @@ public static class AgentsClientExtensions
             Instructions = options.Instructions,
         };
 
-        ApplyToolsToAgentDefinition(agentDefinition, options.ChatOptions?.Tools);
+        ApplyToolsToAgentDefinition(agentDefinition, options.ChatOptions?.Tools, RequireInvocableTools);
 
         AgentVersionCreationOptions? versionCreationOptions = null;
         if (!string.IsNullOrWhiteSpace(options.Description))
@@ -377,16 +377,15 @@ public static class AgentsClientExtensions
 
         AgentVersion agentVersion = agentsClient.CreateAgentVersion(options.Name, agentDefinition, versionCreationOptions, cancellationToken).Value;
 
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
+        var agentOptions = CreateChatClientAgentOptions(agentVersion, options, RequireInvocableTools);
 
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, options);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            agentOptions,
+            clientFactory,
+            openAIClientOptions,
+            RequireInvocableTools);
     }
 
     /// <summary>
@@ -412,6 +411,7 @@ public static class AgentsClientExtensions
         Throw.IfNull(agentsClient);
         Throw.IfNull(options);
         Throw.IfNullOrWhitespace(model);
+        const bool RequireInvocableTools = true;
 
         if (string.IsNullOrWhiteSpace(options.Name))
         {
@@ -423,7 +423,7 @@ public static class AgentsClientExtensions
             Instructions = options.Instructions,
         };
 
-        ApplyToolsToAgentDefinition(agentDefinition, options.ChatOptions?.Tools);
+        ApplyToolsToAgentDefinition(agentDefinition, options.ChatOptions?.Tools, RequireInvocableTools);
 
         AgentVersionCreationOptions? versionCreationOptions = null;
         if (!string.IsNullOrWhiteSpace(options.Description))
@@ -431,18 +431,17 @@ public static class AgentsClientExtensions
             (versionCreationOptions ??= new()).Description = options.Description;
         }
 
-        AgentVersion agentVersion = (await agentsClient.CreateAgentVersionAsync(options.Name, agentDefinition, versionCreationOptions, cancellationToken).ConfigureAwait(false)).Value;
+        AgentVersion agentVersion = await agentsClient.CreateAgentVersionAsync(options.Name, agentDefinition, versionCreationOptions, cancellationToken).ConfigureAwait(false);
 
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
+        var agentOptions = CreateChatClientAgentOptions(agentVersion, options, RequireInvocableTools);
 
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, options);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            agentOptions,
+            clientFactory,
+            openAIClientOptions,
+            RequireInvocableTools);
     }
 
     /// <summary>
@@ -455,6 +454,7 @@ public static class AgentsClientExtensions
     /// <param name="creationOptions">Settings that control the creation of the agent.</param>
     /// <param name="clientFactory">A factory function to customize the creation of the chat client used by the agent.</param>
     /// <param name="openAIClientOptions">An optional <see cref="OpenAIClientOptions"/> for configuring the underlying OpenAI client.</param>
+    /// <param name="requireInvocableTools">This defaults to true and indicates whether to enforce the presence of invocable tools when the AIAgent is created with an agent definition that uses them. Setting this to false will require manual handling of in-proc tool invocations by the caller.</param>
     /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
     /// <returns>A <see cref="ChatClientAgent"/> instance that can be used to perform operations on the newly created agent.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="agentsClient"/> or <paramref name="agentDefinition"/> is <see langword="null"/>.</exception>
@@ -467,6 +467,7 @@ public static class AgentsClientExtensions
         AgentVersionCreationOptions? creationOptions = null,
         Func<IChatClient, IChatClient>? clientFactory = null,
         OpenAIClientOptions? openAIClientOptions = null,
+        bool requireInvocableTools = true,
         CancellationToken cancellationToken = default)
     {
         Throw.IfNull(agentsClient);
@@ -474,19 +475,17 @@ public static class AgentsClientExtensions
         Throw.IfNull(agentDefinition);
 
         ValidateUsingToolsParameter(agentDefinition, tools);
-        ApplyToolsToAgentDefinition(agentDefinition, tools);
+        ApplyToolsToAgentDefinition(agentDefinition, tools, requireInvocableTools);
 
         AgentVersion agentVersion = agentsClient.CreateAgentVersion(name, agentDefinition, creationOptions, cancellationToken).Value;
-        IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
 
-        if (clientFactory is not null)
-        {
-            chatClient = clientFactory(chatClient);
-        }
-
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, tools);
-
-        return new ChatClientAgent(chatClient, agentOptions);
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            tools,
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools);
     }
 
     /// <summary>
@@ -500,6 +499,7 @@ public static class AgentsClientExtensions
     /// <param name="agentVersionCreationOptions">Settings that control the creation of the agent.</param>
     /// <param name="clientFactory">A factory function to customize the creation of the chat client used by the agent.</param>
     /// <param name="openAIClientOptions">An optional <see cref="OpenAIClientOptions"/> for configuring the underlying OpenAI client.</param>
+    /// <param name="requireInvocableTools">This defaults to true and indicates whether to enforce the presence of invocable tools when the AIAgent is created with an agent definition that uses them. Setting this to false will require manual handling of in-proc tool invocations by the caller.</param>
     /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
     /// <returns>A <see cref="ChatClientAgent"/> instance that can be used to perform operations on the newly created agent.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="agentsClient"/> or <paramref name="agentDefinition"/> is <see langword="null"/>.</exception>
@@ -512,6 +512,7 @@ public static class AgentsClientExtensions
         AgentVersionCreationOptions? agentVersionCreationOptions = null,
         Func<IChatClient, IChatClient>? clientFactory = null,
         OpenAIClientOptions? openAIClientOptions = null,
+        bool requireInvocableTools = true,
         CancellationToken cancellationToken = default)
     {
         Throw.IfNullOrWhitespace(name);
@@ -519,9 +520,30 @@ public static class AgentsClientExtensions
         Throw.IfNull(agentDefinition);
 
         ValidateUsingToolsParameter(agentDefinition, tools);
-        ApplyToolsToAgentDefinition(agentDefinition, tools);
+        ApplyToolsToAgentDefinition(agentDefinition, tools, requireInvocableTools);
 
         AgentVersion agentVersion = await agentsClient.CreateAgentVersionAsync(name, agentDefinition, agentVersionCreationOptions, cancellationToken).ConfigureAwait(false);
+
+        return CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            tools,
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools);
+    }
+
+    #region Private
+
+    /// <summary>This method creates an <see cref="ChatClientAgent"/> with the specified ChatClientAgentOptions.</summary>
+    private static ChatClientAgent CreateChatClientAgent(
+        AgentsClient agentsClient,
+        AgentVersion agentVersion,
+        ChatClientAgentOptions agentOptions,
+        Func<IChatClient, IChatClient>? clientFactory,
+        OpenAIClientOptions? openAIClientOptions,
+        bool requireInvocableTools)
+    {
         IChatClient chatClient = new AzureAIAgentChatClient(agentsClient, agentVersion, openAIClientOptions);
 
         if (clientFactory is not null)
@@ -529,18 +551,31 @@ public static class AgentsClientExtensions
             chatClient = clientFactory(chatClient);
         }
 
-        ChatClientAgentOptions agentOptions = CreateChatClientAgentOptions(agentVersion, tools);
-
         return new ChatClientAgent(chatClient, agentOptions);
     }
 
-    #region Private
+    /// <summary>This method creates an <see cref="ChatClientAgent"/> with a auto-generated ChatClientAgentOptions from the specified configuration parameters.</summary>
+    private static ChatClientAgent CreateChatClientAgent(
+        AgentsClient agentsClient,
+        AgentVersion agentVersion,
+        IList<AITool>? tools,
+        Func<IChatClient, IChatClient>? clientFactory,
+        OpenAIClientOptions? openAIClientOptions,
+        bool requireInvocableTools)
+        => CreateChatClientAgent(
+            agentsClient,
+            agentVersion,
+            CreateChatClientAgentOptions(agentVersion, tools, requireInvocableTools),
+            clientFactory,
+            openAIClientOptions,
+            requireInvocableTools);
 
     /// <summary>
     /// This method creates <see cref="ChatClientAgentOptions"/> for the specified <see cref="AgentVersion"/> and the provided tools.
     /// </summary>
     /// <param name="agentVersion">The agent version.</param>
     /// <param name="tools">The tools to use when interacting with the agent.</param>
+    /// <param name="requireInvocableTools">Indicates whether to enforce the presence of invocable tools when the AIAgent is created with an agent definition that uses them.</param>
     /// <returns>The created <see cref="ChatClientAgentOptions"/>.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the agent definition requires in-process tools but none were provided.</exception>
     /// <exception cref="InvalidOperationException">Thrown when the agent definition required tools were not provided.</exception>
@@ -548,7 +583,7 @@ public static class AgentsClientExtensions
     /// This method rebuilds the agent options from the agent definition returned by the version and combine with the in-proc tools when provided
     /// this ensures that all required tools are provided and the definition of the agent options are consistent with the agent definition coming from the server.
     /// </remarks>
-    private static ChatClientAgentOptions CreateChatClientAgentOptions(AgentVersion agentVersion, IList<AITool>? tools)
+    private static ChatClientAgentOptions CreateChatClientAgentOptions(AgentVersion agentVersion, IList<AITool>? tools, bool requireInvocableTools)
     {
         var agentDefinition = agentVersion.Definition;
 
@@ -556,12 +591,12 @@ public static class AgentsClientExtensions
         if (agentDefinition is PromptAgentDefinition { Tools: { Count: > 0 } definitionTools })
         {
             // Check if no tools were provided while the agent definition requires in-proc tools.
-            if (tools is null or { Count: 0 } && definitionTools.Any(t => t is FunctionTool))
+            if (requireInvocableTools && tools is null or { Count: 0 } && definitionTools.Any(t => t is FunctionTool))
             {
                 throw new ArgumentException("The agent definition in-process tools must be provided in the extension method tools parameter.");
             }
 
-            // Agregate all missing in-proc tools for a single error message.
+            // Agregate all missing tools for a single error message.
             List<string>? missingTools = null;
 
             // Check function tools
@@ -570,7 +605,11 @@ public static class AgentsClientExtensions
                 if (responseTool is FunctionTool functionTool)
                 {
                     // Check if a tool with the same type and name exists in the provided tools.
-                    var matchingTool = tools?.FirstOrDefault(t => t is AIFunction tf && functionTool.FunctionName == tf.Name);
+                    var matchingTool = tools?.FirstOrDefault(t =>
+                        requireInvocableTools
+                            ? t is AIFunction tf && functionTool.FunctionName == tf.Name // When invocable tools are required, match only AIFunction.
+                            : t is AIFunctionDeclaration tfd && functionTool.FunctionName == tfd.Name); // Otherwise, matching only AIFunctionDeclaration is sufficient.
+
                     if (matchingTool is null)
                     {
                         (missingTools ??= []).Add($"Function tool: {functionTool.FunctionName}");
@@ -618,9 +657,19 @@ public static class AgentsClientExtensions
         return agentOptions;
     }
 
-    private static ChatClientAgentOptions CreateChatClientAgentOptions(AgentVersion agentVersion, ChatClientAgentOptions? options)
+    /// <summary>
+    /// Creates a new instance of <see cref="ChatClientAgentOptions"/> configured for the specified agent version and
+    /// optional base options.
+    /// </summary>
+    /// <param name="agentVersion">The agent version to use when configuring the chat client agent options.</param>
+    /// <param name="options">An optional <see cref="ChatClientAgentOptions"/> instance whose relevant properties will be copied to the
+    /// returned options. If <see langword="null"/>, only default values are used.</param>
+    /// <param name="requireInvocableTools">Specifies whether the returned options must include invocable tools. Set to <see langword="true"/> to require
+    /// invocable tools; otherwise, <see langword="false"/>.</param>
+    /// <returns>A <see cref="ChatClientAgentOptions"/> instance configured according to the specified parameters.</returns>
+    private static ChatClientAgentOptions CreateChatClientAgentOptions(AgentVersion agentVersion, ChatClientAgentOptions? options, bool requireInvocableTools)
     {
-        var agentOptions = CreateChatClientAgentOptions(agentVersion, options?.ChatOptions?.Tools);
+        var agentOptions = CreateChatClientAgentOptions(agentVersion, options?.ChatOptions?.Tools, requireInvocableTools);
         if (options is not null)
         {
             agentOptions.AIContextProviderFactory = options.AIContextProviderFactory;
@@ -659,7 +708,21 @@ public static class AgentsClientExtensions
         }
     }
 
-    private static void ApplyToolsToAgentDefinition(AgentDefinition agentDefinition, IList<AITool>? tools)
+    /// <summary>
+    /// Adds the specified AI tools to a prompt agent definition, ensuring that all tools are compatible and, if required, invocable.
+    /// </summary>
+    /// <remarks>This method ensures that only compatible and properly constructed tools are added to the agent definition.
+    /// When <paramref name="requireInvocableTools"/> is <see langword="true"/>, all tools must be
+    /// invocable AIFunctions, which can be created using AIFunctionFactory.Create. Tools are converted to ResponseTool
+    /// instances before being added.</remarks>
+    /// <param name="agentDefinition">The agent definition to which the tools will be applied. Must be a PromptAgentDefinition to support tools.</param>
+    /// <param name="tools">A list of AI tools to add to the agent definition. If null or empty, no tools are added.</param>
+    /// <param name="requireInvocableTools">Indicates whether all provided tools must be invocable AI functions. If set to <see langword="true"/>, only
+    /// invocable AIFunctions are accepted.</param>
+    /// <exception cref="ArgumentException">Thrown if <paramref name="agentDefinition"/> is not a <see cref="PromptAgentDefinition"/>.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if <paramref name="requireInvocableTools"/> is <see langword="true"/> and a tool is an
+    /// <see cref="AIFunctionDeclaration"/> that is not invocable, or if a tool cannot be converted to a <see cref="ResponseTool"/>.</exception>
+    private static void ApplyToolsToAgentDefinition(AgentDefinition agentDefinition, IList<AITool>? tools, bool requireInvocableTools)
     {
         if (tools is { Count: > 0 })
         {
@@ -671,7 +734,7 @@ public static class AgentsClientExtensions
             foreach (var tool in tools)
             {
                 // Ensure that any AIFunctions provided are In-Proc, not just the declarations.
-                if (tool is AIFunctionDeclaration and not AIFunction)
+                if (requireInvocableTools && tool is AIFunctionDeclaration and not AIFunction)
                 {
                     throw new InvalidOperationException("When providing functions, they need to be invokable AIFunctions and not non-invokable AIFunctionDeclarations. AIFunctions can be created correctly using AIFunctionFactory.Create");
                 }
diff --git a/dotnet/tests/Microsoft.Agents.AI.AzureAI.Persistent.UnitTests/AgentsClientExtensionsTests.cs b/dotnet/tests/Microsoft.Agents.AI.AzureAI.Persistent.UnitTests/AgentsClientExtensionsTests.cs
index fcf83e4b18..f7ca437d69 100644
--- a/dotnet/tests/Microsoft.Agents.AI.AzureAI.Persistent.UnitTests/AgentsClientExtensionsTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.AzureAI.Persistent.UnitTests/AgentsClientExtensionsTests.cs
@@ -5,6 +5,7 @@ using System.ClientModel;
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.IO;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Azure.AI.Agents;
@@ -174,6 +175,196 @@ public sealed class AgentsClientExtensionsTests
         Assert.Same(testChatClient, retrievedTestClient);
     }
 
+    /// <summary>
+    /// Verify that GetAIAgent with requireInvocableTools=true enforces invocable tools.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithAgentVersion_WithRequireInvocableToolsTrue_EnforcesInvocableTools()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        AgentVersion agentVersion = this.CreateTestAgentVersion();
+        var tools = new List<AITool>
+        {
+            AIFunctionFactory.Create(() => "test", "test_function", "A test function")
+        };
+
+        // Act
+        var agent = client.GetAIAgent(agentVersion, tools: tools, requireInvocableTools: true);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgent with requireInvocableTools=false allows declarative functions.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithAgentVersion_WithRequireInvocableToolsFalse_AllowsDeclarativeFunctions()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        AgentVersion agentVersion = this.CreateTestAgentVersion();
+
+        // Act - should not throw even without tools when requireInvocableTools is false
+        var agent = client.GetAIAgent(agentVersion, requireInvocableTools: false);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    #endregion
+
+    #region GetAIAgent(AgentsClient, ChatClientAgentOptions) Tests
+
+    /// <summary>
+    /// Verify that GetAIAgent with ChatClientAgentOptions throws ArgumentNullException when client is null.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_WithNullClient_ThrowsArgumentNullException()
+    {
+        // Arrange
+        AgentsClient? client = null;
+        var options = new ChatClientAgentOptions { Name = "test-agent" };
+
+        // Act & Assert
+        var exception = Assert.Throws<ArgumentNullException>(() =>
+            client!.GetAIAgent(options));
+
+        Assert.Equal("agentsClient", exception.ParamName);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgent with ChatClientAgentOptions throws ArgumentNullException when options is null.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_WithNullOptions_ThrowsArgumentNullException()
+    {
+        // Arrange
+        var mockClient = new Mock<AgentsClient>();
+
+        // Act & Assert
+        var exception = Assert.Throws<ArgumentNullException>(() =>
+            mockClient.Object.GetAIAgent((ChatClientAgentOptions)null!));
+
+        Assert.Equal("options", exception.ParamName);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgent with ChatClientAgentOptions throws ArgumentException when options.Name is null.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_WithoutName_ThrowsArgumentException()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        var options = new ChatClientAgentOptions();
+
+        // Act & Assert
+        var exception = Assert.Throws<ArgumentException>(() =>
+            client.GetAIAgent(options));
+
+        Assert.Contains("Agent name must be provided", exception.Message);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgent with ChatClientAgentOptions creates a valid agent.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_CreatesValidAgent()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent");
+        var options = new ChatClientAgentOptions { Name = "test-agent" };
+
+        // Act
+        var agent = client.GetAIAgent(options);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.Equal("test-agent", agent.Name);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgent with ChatClientAgentOptions and clientFactory applies the factory.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_WithClientFactory_AppliesFactoryCorrectly()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent");
+        var options = new ChatClientAgentOptions { Name = "test-agent" };
+        TestChatClient? testChatClient = null;
+
+        // Act
+        var agent = client.GetAIAgent(
+            options,
+            clientFactory: (innerClient) => testChatClient = new TestChatClient(innerClient));
+
+        // Assert
+        Assert.NotNull(agent);
+        var retrievedTestClient = agent.GetService<TestChatClient>();
+        Assert.NotNull(retrievedTestClient);
+        Assert.Same(testChatClient, retrievedTestClient);
+    }
+
+    #endregion
+
+    #region GetAIAgentAsync(AgentsClient, ChatClientAgentOptions) Tests
+
+    /// <summary>
+    /// Verify that GetAIAgentAsync with ChatClientAgentOptions throws ArgumentNullException when client is null.
+    /// </summary>
+    [Fact]
+    public async Task GetAIAgentAsync_WithOptions_WithNullClient_ThrowsArgumentNullExceptionAsync()
+    {
+        // Arrange
+        AgentsClient? client = null;
+        var options = new ChatClientAgentOptions { Name = "test-agent" };
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            client!.GetAIAgentAsync(options));
+
+        Assert.Equal("agentsClient", exception.ParamName);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgentAsync with ChatClientAgentOptions throws ArgumentNullException when options is null.
+    /// </summary>
+    [Fact]
+    public async Task GetAIAgentAsync_WithOptions_WithNullOptions_ThrowsArgumentNullExceptionAsync()
+    {
+        // Arrange
+        var mockClient = new Mock<AgentsClient>();
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            mockClient.Object.GetAIAgentAsync((ChatClientAgentOptions)null!));
+
+        Assert.Equal("options", exception.ParamName);
+    }
+
+    /// <summary>
+    /// Verify that GetAIAgentAsync with ChatClientAgentOptions creates a valid agent.
+    /// </summary>
+    [Fact]
+    public async Task GetAIAgentAsync_WithOptions_CreatesValidAgentAsync()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent");
+        var options = new ChatClientAgentOptions { Name = "test-agent" };
+
+        // Act
+        var agent = await client.GetAIAgentAsync(options);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.Equal("test-agent", agent.Name);
+    }
+
     #endregion
 
     #region GetAIAgent(AgentsClient, string) Tests
@@ -532,9 +723,111 @@ public sealed class AgentsClientExtensionsTests
         Assert.Contains("Agent name must be provided", exception.Message);
     }
 
+    /// <summary>
+    /// Verify that CreateAIAgent with model and options creates a valid agent.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithModelAndOptions_CreatesValidAgent()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", instructions: "Test instructions");
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Test instructions"
+        };
+
+        // Act
+        var agent = client.CreateAIAgent("test-model", options);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.Equal("test-agent", agent.Name);
+        Assert.Equal("Test instructions", agent.Instructions);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgent with model and options and clientFactory applies the factory.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithModelAndOptions_WithClientFactory_AppliesFactoryCorrectly()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", instructions: "Test instructions");
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Test instructions"
+        };
+        TestChatClient? testChatClient = null;
+
+        // Act
+        var agent = client.CreateAIAgent(
+            "test-model",
+            options,
+            clientFactory: (innerClient) => testChatClient = new TestChatClient(innerClient));
+
+        // Assert
+        Assert.NotNull(agent);
+        var retrievedTestClient = agent.GetService<TestChatClient>();
+        Assert.NotNull(retrievedTestClient);
+        Assert.Same(testChatClient, retrievedTestClient);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgentAsync with model and options creates a valid agent.
+    /// </summary>
+    [Fact]
+    public async Task CreateAIAgentAsync_WithModelAndOptions_CreatesValidAgentAsync()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", instructions: "Test instructions");
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Test instructions"
+        };
+
+        // Act
+        var agent = await client.CreateAIAgentAsync("test-model", options);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.Equal("test-agent", agent.Name);
+        Assert.Equal("Test instructions", agent.Instructions);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgentAsync with model and options and clientFactory applies the factory.
+    /// </summary>
+    [Fact]
+    public async Task CreateAIAgentAsync_WithModelAndOptions_WithClientFactory_AppliesFactoryCorrectlyAsync()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", instructions: "Test instructions");
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Test instructions"
+        };
+        TestChatClient? testChatClient = null;
+
+        // Act
+        var agent = await client.CreateAIAgentAsync(
+            "test-model",
+            options,
+            clientFactory: (innerClient) => testChatClient = new TestChatClient(innerClient));
+
+        // Assert
+        Assert.NotNull(agent);
+        var retrievedTestClient = agent.GetService<TestChatClient>();
+        Assert.NotNull(retrievedTestClient);
+        Assert.Same(testChatClient, retrievedTestClient);
+    }
+
     #endregion
 
-    #region CreateAIAgentAsync Tests
+    #region CreateAIAgentAsync(AgentsClient, string, AgentDefinition) Tests
 
     /// <summary>
     /// Verify that CreateAIAgentAsync throws ArgumentNullException when agentsClient is null.
@@ -591,6 +884,68 @@ public sealed class AgentsClientExtensionsTests
         Assert.Contains("dedicated tools parameter", exception.Message);
     }
 
+    /// <summary>
+    /// Verify that CreateAIAgent with requireInvocableTools=true enforces invocable tools.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithRequireInvocableToolsTrue_EnforcesInvocableTools()
+    {
+        // Arrange
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+        var tools = new List<AITool>
+        {
+            AIFunctionFactory.Create(() => "test", "test_function", "A test function")
+        };
+
+        var definitionResponse = GeneratePromptDefinitionResponse(definition, tools);
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definitionResponse);
+
+        // Act
+        var agent = client.CreateAIAgent("test-agent", definition, tools: tools, requireInvocableTools: true);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgent with requireInvocableTools=false allows declarative functions.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithRequireInvocableToolsFalse_AllowsDeclarativeFunctions()
+    {
+        // Arrange
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definition);
+
+        // Act - should not throw even without tools when requireInvocableTools is false
+        var agent = client.CreateAIAgent("test-agent", definition, requireInvocableTools: false);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgent throws ArgumentException when agent definition has tools but none provided as parameter.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithDefinitionToolsButNoToolsParameter_ThrowsArgumentException()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+
+        // Add a function tool to the definition to simulate a tool requirement
+        definition.Tools.Add(ResponseTool.CreateFunctionTool("required_tool", BinaryData.FromString("{}"), strictModeEnabled: false));
+
+        // Act & Assert
+        var exception = Assert.Throws<ArgumentException>(() =>
+            client.CreateAIAgent("test-agent", definition, tools: null, requireInvocableTools: true));
+
+        Assert.Contains("dedicated tools parameter", exception.Message);
+    }
+
     /// <summary>
     /// Verify that CreateAIAgent with tools parameter applies tools to the agent definition.
     /// </summary>
@@ -888,6 +1243,209 @@ public sealed class AgentsClientExtensionsTests
 
     #endregion
 
+    #region Declarative Function Handling Tests
+
+    /// <summary>
+    /// Verify that CreateAIAgent throws InvalidOperationException when provided with non-invocable AIFunctionDeclaration when requireInvocableTools=true.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithDeclarativeFunctionAndRequireInvocableTrue_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+
+        // Create a declarative function (not invocable) using AIFunctionFactory.CreateDeclaration
+        using var doc = JsonDocument.Parse("{}");
+        var declarativeFunction = AIFunctionFactory.CreateDeclaration("test_function", "A test function", doc.RootElement);
+
+        var tools = new List<AITool> { declarativeFunction };
+
+        // Act & Assert
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            client.CreateAIAgent("test-agent", definition, tools: tools, requireInvocableTools: true));
+
+        Assert.Contains("invokable AIFunctions", exception.Message);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgent accepts declarative functions when requireInvocableTools=false.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithDeclarativeFunctionAndRequireInvocableFalse_AcceptsDeclarativeFunction()
+    {
+        // Arrange
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+
+        // Create a declarative function (not invocable) using AIFunctionFactory.CreateDeclaration
+        using var doc = JsonDocument.Parse("{}");
+        var declarativeFunction = AIFunctionFactory.CreateDeclaration("test_function", "A test function", doc.RootElement);
+
+        var tools = new List<AITool> { declarativeFunction };
+
+        // Generate response with the declarative function
+        var definitionResponse = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+        definitionResponse.Tools.Add(declarativeFunction.AsOpenAIResponseTool() ?? throw new InvalidOperationException());
+
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definitionResponse);
+
+        // Act
+        var agent = client.CreateAIAgent("test-agent", definition, tools: tools, requireInvocableTools: false);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgentAsync throws InvalidOperationException when provided with non-invocable AIFunctionDeclaration when requireInvocableTools=true.
+    /// </summary>
+    [Fact]
+    public async Task CreateAIAgentAsync_WithDeclarativeFunctionAndRequireInvocableTrue_ThrowsInvalidOperationExceptionAsync()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient();
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+
+        // Create a declarative function (not invocable) using AIFunctionFactory.CreateDeclaration
+        using var doc = JsonDocument.Parse("{}");
+        var declarativeFunction = AIFunctionFactory.CreateDeclaration("test_function", "A test function", doc.RootElement);
+
+        var tools = new List<AITool> { declarativeFunction };
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            client.CreateAIAgentAsync("test-agent", definition, tools: tools, requireInvocableTools: true));
+
+        Assert.Contains("invokable AIFunctions", exception.Message);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgentAsync accepts declarative functions when requireInvocableTools=false.
+    /// </summary>
+    [Fact]
+    public async Task CreateAIAgentAsync_WithDeclarativeFunctionAndRequireInvocableFalse_AcceptsDeclarativeFunctionAsync()
+    {
+        // Arrange
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+
+        // Create a declarative function (not invocable) using AIFunctionFactory.CreateDeclaration
+        using var doc = JsonDocument.Parse("{}");
+        var declarativeFunction = AIFunctionFactory.CreateDeclaration("test_function", "A test function", doc.RootElement);
+
+        var tools = new List<AITool> { declarativeFunction };
+
+        // Generate response with the declarative function
+        var definitionResponse = new PromptAgentDefinition("test-model") { Instructions = "Test" };
+        definitionResponse.Tools.Add(declarativeFunction.AsOpenAIResponseTool() ?? throw new InvalidOperationException());
+
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definitionResponse);
+
+        // Act
+        var agent = await client.CreateAIAgentAsync("test-agent", definition, tools: tools, requireInvocableTools: false);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.IsType<ChatClientAgent>(agent);
+    }
+
+    #endregion
+
+    #region Options Generation Validation Tests
+
+    /// <summary>
+    /// Verify that ChatClientAgentOptions are generated correctly with proper tool matching.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_GeneratesCorrectChatClientAgentOptions()
+    {
+        // Arrange
+        var definition = new PromptAgentDefinition("test-model") { Instructions = "Test instructions" };
+        var tools = new List<AITool>
+        {
+            AIFunctionFactory.Create(() => "result", "test_tool", "A test tool")
+        };
+
+        var definitionResponse = GeneratePromptDefinitionResponse(definition, tools);
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definitionResponse);
+
+        // Act
+        var agent = client.CreateAIAgent("test-agent", definition, tools: tools);
+
+        // Assert
+        Assert.NotNull(agent);
+        var agentVersion = agent.GetService<AgentVersion>();
+        Assert.NotNull(agentVersion);
+        Assert.Equal("test-agent", agentVersion.Name);
+        Assert.Equal("Test instructions", (agentVersion.Definition as PromptAgentDefinition)?.Instructions);
+    }
+
+    /// <summary>
+    /// Verify that ChatClientAgentOptions preserve custom properties from input options.
+    /// </summary>
+    [Fact]
+    public void GetAIAgent_WithOptions_PreservesCustomProperties()
+    {
+        // Arrange
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", instructions: "Custom instructions", description: "Custom description");
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Custom instructions",
+            Description = "Custom description"
+        };
+
+        // Act
+        var agent = client.GetAIAgent(options);
+
+        // Assert
+        Assert.NotNull(agent);
+        Assert.Equal("test-agent", agent.Name);
+        Assert.Equal("Custom instructions", agent.Instructions);
+        Assert.Equal("Custom description", agent.Description);
+    }
+
+    /// <summary>
+    /// Verify that CreateAIAgent with options generates correct ChatClientAgentOptions with tools.
+    /// </summary>
+    [Fact]
+    public void CreateAIAgent_WithOptionsAndTools_GeneratesCorrectOptions()
+    {
+        // Arrange
+        var tools = new List<AITool>
+        {
+            AIFunctionFactory.Create(() => "result", "option_tool", "A tool from options")
+        };
+
+        var definitionResponse = GeneratePromptDefinitionResponse(
+            new PromptAgentDefinition("test-model") { Instructions = "Test" },
+            tools);
+
+        AgentsClient client = this.CreateTestAgentsClient(agentName: "test-agent", agentDefinitionResponse: definitionResponse);
+
+        var options = new ChatClientAgentOptions
+        {
+            Name = "test-agent",
+            Instructions = "Test",
+            ChatOptions = new ChatOptions { Tools = tools }
+        };
+
+        // Act
+        var agent = client.CreateAIAgent("test-model", options);
+
+        // Assert
+        Assert.NotNull(agent);
+        var agentVersion = agent.GetService<AgentVersion>();
+        Assert.NotNull(agentVersion);
+        if (agentVersion.Definition is PromptAgentDefinition promptDef)
+        {
+            Assert.NotEmpty(promptDef.Tools);
+            Assert.Single(promptDef.Tools);
+        }
+    }
+
+    #endregion
+
     #region AzureAIChatClient Behavior Tests
 
     /// <summary>