New Feature: IGuardrailProvider interface for policy-based function invocation control
Los mantenedores suelen responder en 3 días
Nadie ha tomado este issue todavía.
Evaluación
- Dificultad
- 5/5
- Tiempo estimado
- Más de una semana
- Aptitud para principiantes
- 35/100
- Tipo de issue
- Nueva funcionalidad
- Claridad
- Bastante claro
- Estado de actividad
- Tranquilo
- Área
- ai, authorization, security
Línea de trabajo
Comience con el pipeline existente de IAutoFunctionInvocationFilter y sus puntos de entrada de .NET y Python; después, compare cómo se registran los filtros y cómo se representan el contexto de invocación y los resultados. Se considera terminado cuando se hayan definido de forma coherente un contrato de proveedor y la integración de filtros para ambos lenguajes, incluido el comportamiento de permitir, denegar, cancelar y registrar.
Escrito por el modelo de indexación a partir del texto del issue.
Descripción
Feature Request
Title: New Feature: IGuardrailProvider interface for policy-based function invocation control
Is your feature request related to a problem?
Enterprise deployments of Semantic Kernel agents need a standardized way to enforce authorization policies on function invocations -- deciding whether a tool call should proceed based on caller identity, resource scope, risk level, or organizational policy. Today this is achievable through IAutoFunctionInvocationFilter, but each team builds ad-hoc policy logic inside their filter implementations with no shared contract for pluggable policy providers.
This gap has been raised repeatedly:
- #1409 -- "Guardrails for C#" (2023, closed with TypeChat redirect, no guardrail interface shipped)
- #5436 -- "Filters use cases to be supported before making feature non-experimental" (explicitly lists "Function Call Approval" as a core requirement)
- #10951 -- "Agent Invocation Filter" (2025, requesting filters that wrap agent invocations "allowing for scenarios like guardrails etc." for both .NET and Python)
- #13556 -- "Governance Policy Filter for Semantic Kernel" (2026, proposed a governance layer, closed and redirected to microsoft/agent-governance-toolkit)
- #12294 -- Handoff orchestration triggering OpenAI jailbreak guardrails (demonstrates the practical need for pre-invocation policy checks)
Describe the solution you'd like
A thin IGuardrailProvider interface that plugs into the existing filter pipeline. It separates the policy decision (should this call proceed?) from the filter mechanics (intercepting the pipeline).
C# (.NET)
namespace Microsoft.SemanticKernel;
/// <summary>
/// Provides policy-based authorization decisions for function invocations.
/// Implementations are registered with the Kernel and consulted by a
/// built-in AutoFunctionInvocationFilter before each tool call.
/// </summary>
public interface IGuardrailProvider
{
/// <summary>
/// Evaluates whether a function invocation should proceed.
/// </summary>
Task<GuardrailDecision> EvaluateAsync(
GuardrailContext context,
CancellationToken cancellationToken = default);
}
public sealed class GuardrailContext
{
public KernelFunction Function { get; init; }
public KernelArguments Arguments { get; init; }
public AutoFunctionInvocationContext InvocationContext { get; init; }
/// <summary>Optional caller identity for multi-tenant scenarios.</summary>
public ClaimsPrincipal? Principal { get; init; }
}
public sealed class GuardrailDecision
{
public bool IsAllowed { get; init; }
public string? Reason { get; init; }
public static GuardrailDecision Allow() => new() { IsAllowed = true };
public static GuardrailDecision Deny(string reason) =>
new() { IsAllowed = false, Reason = reason };
}
Python
from abc import ABC, abstractmethod
from dataclasses import dataclass
from semantic_kernel.filters.auto_function_invocation.auto_function_invocation_context import (
AutoFunctionInvocationContext,
)
@dataclass
class GuardrailContext:
function_name: str
plugin_name: str
arguments: dict
invocation_context: AutoFunctionInvocationContext
principal: dict | None = None # Caller identity claims
@dataclass
class GuardrailDecision:
is_allowed: bool
reason: str | None = None
@staticmethod
def allow() -> "GuardrailDecision":
return GuardrailDecision(is_allowed=True)
@staticmethod
def deny(reason: str) -> "GuardrailDecision":
return GuardrailDecision(is_allowed=False, reason=reason)
class GuardrailProvider(ABC):
@abstractmethod
async def evaluate(self, context: GuardrailContext) -> GuardrailDecision:
"""Return whether this function invocation should proceed."""
...
Integration with existing filters
The provider does not replace filters -- it plugs into them. A built-in GuardrailAutoFunctionInvocationFilter consults registered providers:
public class GuardrailAutoFunctionInvocationFilter : IAutoFunctionInvocationFilter
{
private readonly IEnumerable<IGuardrailProvider> _providers;
public async Task OnAutoFunctionInvocationAsync(
AutoFunctionInvocationContext context,
Func<AutoFunctionInvocationContext, Task> next)
{
var guardrailContext = new GuardrailContext
{
Function = context.Function,
Arguments = context.Arguments,
InvocationContext = context
};
foreach (var provider in _providers)
{
var decision = await provider.EvaluateAsync(guardrailContext);
if (!decision.IsAllowed)
{
context.Result = new FunctionResult(context.Function,
$"Blocked by guardrail: {decision.Reason}");
return; // skip next -- do not invoke function
}
}
await next(context);
}
}
Registration
var kernel = Kernel.CreateBuilder()
.AddAzureOpenAIChatCompletion(...)
.Build();
kernel.AutoFunctionInvocationFilters.Add(
new GuardrailAutoFunctionInvocationFilter(
new MyOrgPolicyProvider(),
new AzureContentSafetyProvider()
));
Describe alternatives you've considered
- Raw
IAutoFunctionInvocationFilteronly -- Works today, but every team re-invents the allow/deny pattern. No shared contract means no ecosystem of pluggable providers. - External governance toolkit -- #13556 was redirected to microsoft/agent-governance-toolkit, but a lightweight in-kernel interface would enable third-party providers without requiring a separate toolkit dependency.
Why this fits Semantic Kernel's architecture
- Follows the existing filter pipeline pattern (
IAutoFunctionInvocationFilter,IFunctionInvocationFilter,IPromptRenderFilter) - Does not modify the filter contract -- composes on top of it
- Supports the "Function Call Approval" scenario explicitly called out in #5436
- Works for both .NET and Python with identical semantics
- Enables the agent-level guardrails requested in #10951
Additional context
A reference implementation of this provider pattern exists in APort Agent Guardrails, which enforces passport-based tool authorization policies for AI agents. The interface proposed here is deliberately provider-agnostic so that any policy backend (Azure Content Safety, OPA, custom rules, etc.) can plug in.
- Lenguaje dominante
- C#
- Estrellas
- 28.8k
- Forks
- 4.9k
- Merge medio
- 2 d 17 h
- PR fusionados (30 d)
- 48
Preparar el entorno
Inicia el contenedor de desarrollo del proyecto en tu navegador, con tu propia cuenta de GitHub.
- Sin Dockerfile ni archivo de Docker Compose
- Tiene una plantilla de pull request
- Leer la guía de contribución
Primeros pasos
- Lee el issue completo y luego la guía de contribución del proyecto.
- Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
- Haz un fork del repositorio y trabaja en una rama.
- Abre un pull request que haga referencia al número del issue.
Más de microsoft/semantic-kernel
-
Python: Bug: ChatMessageContent.from_element drops AudioContent and BinaryContent into raw TextContentPosiblemente ocupada @halcyon-past la tomó hoy. Abierto
Dificultad 2/5 1-3 horas Aptitud para principiantes 75/100
microsoft/semantic-kernel#14824 · 1 comentario ·
Los mantenedores suelen responder en 3 días
-
Python: Bug: Redis search returns None for every field that declares a storage_name, because RETURN lists the declared namePosiblemente ocupada @wasim-builds la tomó hace 9 días. Abiertopython triage
Dificultad 2/5 1-3 horas Aptitud para principiantes 78/100
microsoft/semantic-kernel#14753 · 1 comentario ·
Los mantenedores suelen responder en 3 días
-
.Net: gpt-image-1 is the default image model in the .NET OpenAI connector, and OpenAI shuts it down on October 23Posiblemente ocupada @nightcityblade la tomó hace 46 días. Abierto.NET triage
Dificultad 2/5 1-3 horas Aptitud para principiantes 73/100
microsoft/semantic-kernel#14526 · 1 comentario ·
Los mantenedores suelen responder en 3 días
-
Python: VolatileMemoryStore.get_batch and get_nearest_matches ignore with_embeddings=False (deepcopy result is discarded)Posiblemente ocupada @VANDRANKI la tomó hace 48 días. Abiertopython triage
Dificultad 2/5 1-3 horas Aptitud para principiantes 84/100
microsoft/semantic-kernel#14522 ·
Los mantenedores suelen responder en 3 días
-
.Net: Bug: BinaryContent does not decode the %xx escapes of a non-base64 data URIPosiblemente ocupada @Laurianti la tomó hace 48 días. Abierto.NET triage
Dificultad 2/5 1-3 horas Aptitud para principiantes 76/100
microsoft/semantic-kernel#14518 ·
Los mantenedores suelen responder en 3 días
Todos los issues de microsoft/semantic-kernel
Issues similares
-
Dificultad 2/5 1-3 horas Aptitud para principiantes 75/100
Los mantenedores suelen responder en 1 día
-
Support Flux ignore rules (drift detection ignore paths) in Microsoft.KubernetesConfiguration schemaAbierto
Dificultad 2/5 1-3 horas Aptitud para principiantes 65/100
Azure/azure-resource-manager-schemas#3921 ·
Los mantenedores suelen responder en 1 día
-
text-align: justify is ignored in HTML to PDF conversionPosiblemente ocupada @PrzemyslawKlys la tomó hoy. Abierto
Dificultad 2/5 1-3 horas Aptitud para principiantes 82/100
Los mantenedores suelen responder en 1 día
-
Dificultad 1/5 Menos de una hora Aptitud para principiantes 78/100
Los mantenedores suelen responder en 4 días
-
Dificultad 2/5 1-3 horas Aptitud para principiantes 75/100
asyncapi/modelina#2709 · 1 comentario ·
Los mantenedores suelen responder en 1 día