< Summary

Information
Class: NexusLabs.Needlr.AgentFramework.AgentFrameworkGeneratedBootstrap
Assembly: NexusLabs.Needlr.AgentFramework
File(s): /home/runner/work/needlr/needlr/src/NexusLabs.Needlr.AgentFramework/AgentFrameworkGeneratedBootstrap.cs
Line coverage
75%
Covered lines: 198
Uncovered lines: 66
Coverable lines: 264
Total lines: 538
Line coverage: 75%
Branch coverage
48%
Covered branches: 48
Total branches: 98
Branch coverage: 48.9%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_FunctionTypes()100%11100%
get_GroupTypes()100%11100%
get_AgentTypes()100%11100%
get_HandoffTopology()100%11100%
get_GroupChatGroups()100%11100%
get_SequentialTopology()100%11100%
.cctor()100%11100%
RegisterAIFunctionProvider(...)100%11100%
TryGetAIFunctionProvider(...)100%22100%
RegisterGraphTopology(...)100%11100%
TryGetGraphTopology(...)0%2040%
Register(...)50%22100%
TryGetFunctionTypes(...)50%5466.66%
TryGetGroupTypes(...)75%4483.33%
TryGetAgentTypes(...)75%4483.33%
TryGetHandoffTopology(...)75%4483.33%
TryGetGroupChatGroups(...)75%4483.33%
TryGetSequentialTopology(...)75%4483.33%
BeginTestScope(...)100%66100%
EnsureCombined()40.74%1315470.21%
EnsureCombinedGraphTopology()0%4260%
.ctor(...)100%11100%
Dispose()100%11100%

File(s)

/home/runner/work/needlr/needlr/src/NexusLabs.Needlr.AgentFramework/AgentFrameworkGeneratedBootstrap.cs

#LineLine coverage
 1using System.Diagnostics.CodeAnalysis;
 2
 3namespace NexusLabs.Needlr.AgentFramework;
 4
 5/// <summary>
 6/// Runtime bootstrap registry for source-generated Agent Framework components.
 7/// </summary>
 8/// <remarks>
 9/// The source generator emits a <c>[ModuleInitializer]</c> in the host assembly that calls
 10/// <see cref="Register"/> with the generated type providers.
 11/// <c>UsingAgentFramework()</c> checks this bootstrap
 12/// and auto-populates function types, groups, and agent types without requiring any explicit
 13/// <c>Add*FromGenerated()</c> calls.
 14/// </remarks>
 15public static class AgentFrameworkGeneratedBootstrap
 16{
 17    private sealed class Registration
 18    {
 3219        public Registration(
 3220            Func<IReadOnlyList<Type>> functionTypes,
 3221            Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> groupTypes,
 3222            Func<IReadOnlyList<Type>> agentTypes,
 3223            Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>> handoffTopology,
 3224            Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> groupChatGroups,
 3225            Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> sequentialTopology)
 26        {
 3227            FunctionTypes = functionTypes;
 3228            GroupTypes = groupTypes;
 3229            AgentTypes = agentTypes;
 3230            HandoffTopology = handoffTopology;
 3231            GroupChatGroups = groupChatGroups;
 3232            SequentialTopology = sequentialTopology;
 3233        }
 34
 235        public Func<IReadOnlyList<Type>> FunctionTypes { get; }
 436        public Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> GroupTypes { get; }
 437        public Func<IReadOnlyList<Type>> AgentTypes { get; }
 538        public Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>> HandoffTopology 
 539        public Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> GroupChatGroups { get; }
 540        public Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> SequentialTopology { get; }
 41    }
 42
 1643    private static readonly object _gate = new();
 1644    private static readonly List<Registration> _registrations = [];
 1645    private static readonly AsyncLocal<Registration?> _asyncLocalOverride = new();
 46    private static IAIFunctionProvider? _aiFunctionProvider;
 1647    private static readonly AsyncLocal<IAIFunctionProvider?> _asyncLocalProviderOverride = new();
 1648    private static readonly List<Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>> _graphTopologyRegistratio
 1649    private static readonly AsyncLocal<Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>?> _asyncLocalGraphTo
 50    private static Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>? _cachedCombinedGraphTopology;
 51
 52    private static (
 53        Func<IReadOnlyList<Type>> Functions,
 54        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> Groups,
 55        Func<IReadOnlyList<Type>> Agents,
 56        Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>> HandoffTopology,
 57        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> GroupChatGroups,
 58        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> SequentialTopology)? _cachedCombined;
 59
 60    /// <summary>
 61    /// Registers the generated <see cref="IAIFunctionProvider"/> for this assembly.
 62    /// Called automatically by the generator-emitted <c>[ModuleInitializer]</c>.
 63    /// </summary>
 64    public static void RegisterAIFunctionProvider(IAIFunctionProvider provider)
 65    {
 1966        ArgumentNullException.ThrowIfNull(provider);
 1967        _aiFunctionProvider = provider;
 1968    }
 69
 70    /// <summary>
 71    /// Gets the registered <see cref="IAIFunctionProvider"/>, if one has been registered.
 72    /// </summary>
 73    public static bool TryGetAIFunctionProvider([NotNullWhen(true)] out IAIFunctionProvider? provider)
 74    {
 32075        var local = _asyncLocalProviderOverride.Value;
 32076        if (local is not null)
 77        {
 278            provider = local;
 279            return true;
 80        }
 81
 31882        provider = _aiFunctionProvider;
 31883        return provider is not null;
 84    }
 85
 86    /// <summary>
 87    /// Registers compile-time graph topology data for this assembly.
 88    /// Called automatically by the generator-emitted <c>[ModuleInitializer]</c>.
 89    /// </summary>
 90    public static void RegisterGraphTopology(
 91        Func<IReadOnlyDictionary<string, GraphTopologyRegistration>> graphTopology)
 92    {
 1993        ArgumentNullException.ThrowIfNull(graphTopology);
 1994        lock (_gate)
 95        {
 1996            _graphTopologyRegistrations.Add(graphTopology);
 1997            _cachedCombinedGraphTopology = null;
 1998        }
 1999    }
 100
 101    /// <summary>
 102    /// Gets the combined graph topology provider from all registered assemblies.
 103    /// </summary>
 104    public static bool TryGetGraphTopology(
 105        [NotNullWhen(true)] out Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>? provider)
 106    {
 0107        var local = _asyncLocalGraphTopologyOverride.Value;
 0108        if (local is not null)
 109        {
 0110            provider = local;
 0111            return true;
 112        }
 113
 0114        lock (_gate)
 115        {
 0116            if (_graphTopologyRegistrations.Count == 0)
 117            {
 0118                provider = null;
 0119                return false;
 120            }
 121
 0122            EnsureCombinedGraphTopology();
 0123            provider = _cachedCombinedGraphTopology;
 0124            return provider is not null;
 125        }
 0126    }
 127
 128    /// <summary>
 129    /// Registers the generated type providers for this assembly.
 130    /// Called automatically by the generator-emitted <c>[ModuleInitializer]</c>.
 131    /// </summary>
 132    public static void Register(
 133        Func<IReadOnlyList<Type>> functionTypes,
 134        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> groupTypes,
 135        Func<IReadOnlyList<Type>> agentTypes,
 136        Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>> handoffTopology,
 137        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> groupChatGroups,
 138        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? sequentialTopology = null)
 139    {
 19140        ArgumentNullException.ThrowIfNull(functionTypes);
 19141        ArgumentNullException.ThrowIfNull(groupTypes);
 19142        ArgumentNullException.ThrowIfNull(agentTypes);
 19143        ArgumentNullException.ThrowIfNull(handoffTopology);
 19144        ArgumentNullException.ThrowIfNull(groupChatGroups);
 19145        sequentialTopology ??= static () => new Dictionary<string, IReadOnlyList<Type>>();
 146
 19147        lock (_gate)
 148        {
 19149            _registrations.Add(new Registration(functionTypes, groupTypes, agentTypes, handoffTopology, groupChatGroups,
 19150            _cachedCombined = null;
 19151        }
 19152    }
 153
 154    /// <summary>
 155    /// Gets the combined function type provider from all registered assemblies.
 156    /// </summary>
 157    public static bool TryGetFunctionTypes([NotNullWhen(true)] out Func<IReadOnlyList<Type>>? provider)
 158    {
 179159        var local = _asyncLocalOverride.Value;
 179160        if (local is not null)
 161        {
 0162            provider = local.FunctionTypes;
 0163            return true;
 164        }
 165
 179166        lock (_gate)
 167        {
 179168            if (_registrations.Count == 0)
 169            {
 0170                provider = null;
 0171                return false;
 172            }
 173
 179174            EnsureCombined();
 179175            provider = _cachedCombined!.Value.Functions;
 179176            return true;
 177        }
 179178    }
 179
 180    /// <summary>
 181    /// Gets the combined function group provider from all registered assemblies.
 182    /// </summary>
 183    public static bool TryGetGroupTypes([NotNullWhen(true)] out Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? 
 184    {
 208185        var local = _asyncLocalOverride.Value;
 208186        if (local is not null)
 187        {
 2188            provider = local.GroupTypes;
 2189            return true;
 190        }
 191
 206192        lock (_gate)
 193        {
 206194            if (_registrations.Count == 0)
 195            {
 0196                provider = null;
 0197                return false;
 198            }
 199
 206200            EnsureCombined();
 206201            provider = _cachedCombined!.Value.Groups;
 206202            return true;
 203        }
 206204    }
 205
 206    /// <summary>
 207    /// Gets the combined agent type provider from all registered assemblies.
 208    /// </summary>
 209    public static bool TryGetAgentTypes([NotNullWhen(true)] out Func<IReadOnlyList<Type>>? provider)
 210    {
 126211        var local = _asyncLocalOverride.Value;
 126212        if (local is not null)
 213        {
 2214            provider = local.AgentTypes;
 2215            return true;
 216        }
 217
 124218        lock (_gate)
 219        {
 124220            if (_registrations.Count == 0)
 221            {
 0222                provider = null;
 0223                return false;
 224            }
 225
 124226            EnsureCombined();
 124227            provider = _cachedCombined!.Value.Agents;
 124228            return true;
 229        }
 124230    }
 231
 232    /// <summary>
 233    /// Gets the combined handoff topology provider from all registered assemblies.
 234    /// </summary>
 235    public static bool TryGetHandoffTopology(
 236        [NotNullWhen(true)] out Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>>
 237    {
 9238        var local = _asyncLocalOverride.Value;
 9239        if (local is not null)
 240        {
 3241            provider = local.HandoffTopology;
 3242            return true;
 243        }
 244
 6245        lock (_gate)
 246        {
 6247            if (_registrations.Count == 0)
 248            {
 0249                provider = null;
 0250                return false;
 251            }
 252
 6253            EnsureCombined();
 6254            provider = _cachedCombined!.Value.HandoffTopology;
 6255            return true;
 256        }
 6257    }
 258
 259    /// <summary>
 260    /// Gets the combined group chat groups provider from all registered assemblies.
 261    /// </summary>
 262    public static bool TryGetGroupChatGroups(
 263        [NotNullWhen(true)] out Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? provider)
 264    {
 16265        var local = _asyncLocalOverride.Value;
 16266        if (local is not null)
 267        {
 3268            provider = local.GroupChatGroups;
 3269            return true;
 270        }
 271
 13272        lock (_gate)
 273        {
 13274            if (_registrations.Count == 0)
 275            {
 0276                provider = null;
 0277                return false;
 278            }
 279
 13280            EnsureCombined();
 13281            provider = _cachedCombined!.Value.GroupChatGroups;
 13282            return true;
 283        }
 13284    }
 285
 286    /// <summary>
 287    /// Gets the combined sequential topology provider from all registered assemblies.
 288    /// </summary>
 289    public static bool TryGetSequentialTopology(
 290        [NotNullWhen(true)] out Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? provider)
 291    {
 8292        var local = _asyncLocalOverride.Value;
 8293        if (local is not null)
 294        {
 3295            provider = local.SequentialTopology;
 3296            return true;
 297        }
 298
 5299        lock (_gate)
 300        {
 5301            if (_registrations.Count == 0)
 302            {
 0303                provider = null;
 0304                return false;
 305            }
 306
 5307            EnsureCombined();
 5308            provider = _cachedCombined!.Value.SequentialTopology;
 5309            return true;
 310        }
 5311    }
 312
 313    /// <summary>
 314    /// Creates a test-scoped override that replaces bootstrap discovery for the current async context.
 315    /// Dispose the returned scope to restore the previous state.
 316    /// </summary>
 317    /// <param name="functionTypes">
 318    /// Provider for the set of <c>[AgentFunction]</c>-bearing types visible inside the scope.
 319    /// Use <c>static () =&gt; []</c> for an empty registry.
 320    /// </param>
 321    /// <param name="groupTypes">
 322    /// Provider for the <c>[AgentFunctionGroup]</c> name â†’ type list map visible inside the scope.
 323    /// </param>
 324    /// <param name="agentTypes">
 325    /// Provider for the set of <c>[NeedlrAiAgent]</c>-decorated agent types visible inside the scope.
 326    /// </param>
 327    /// <param name="handoffTopology">
 328    /// Optional handoff edges built by the <c>[AgentHandoffsTo]</c> generator. Defaults to empty.
 329    /// </param>
 330    /// <param name="groupChatGroups">
 331    /// Optional group-chat membership built by the <c>[AgentGroupChatMember]</c> generator. Defaults to empty.
 332    /// </param>
 333    /// <param name="sequentialTopology">
 334    /// Optional sequential-pipeline topology built by the <c>[AgentSequenceMember]</c> generator. Defaults to empty.
 335    /// </param>
 336    /// <param name="aiFunctionProvider">
 337    /// Optional source-generated <see cref="IAIFunctionProvider"/> to install for the scope.
 338    /// Pass <see langword="null"/> to fall back to reflection-based <see cref="Microsoft.Extensions.AI.AIFunction"/> cr
 339    /// inside the scope.
 340    /// </param>
 341    /// <returns>
 342    /// A disposable scope. The override is restored to its previous value when the returned object is disposed.
 343    /// </returns>
 344    /// <remarks>
 345    /// <para>
 346    /// This is the preferred mechanism for test isolation when consumer test projects contain many
 347    /// <c>[AgentFunction]</c>, <c>[AgentFunctionGroup]</c>, or <c>[NeedlrAiAgent]</c> types: the
 348    /// generated <c>[ModuleInitializer]</c> registers <em>all</em> of them globally, so a test
 349    /// targeting a specific subset can use <c>BeginTestScope</c> to limit visibility for the
 350    /// duration of the test without disturbing other tests running concurrently in different async
 351    /// flows.
 352    /// </para>
 353    /// <para>
 354    /// The override is keyed to <see cref="AsyncLocal{T}"/>, so concurrent tests in unrelated async
 355    /// flows do not interfere with each other.
 356    /// </para>
 357    /// <example>
 358    /// <code>
 359    /// [Fact]
 360    /// public void OnlyMyToolIsVisible()
 361    /// {
 362    ///     using var scope = AgentFrameworkGeneratedBootstrap.BeginTestScope(
 363    ///         functionTypes: static () =&gt; [typeof(MyTool)],
 364    ///         groupTypes:    static () =&gt; new Dictionary&lt;string, IReadOnlyList&lt;Type&gt;&gt;(),
 365    ///         agentTypes:    static () =&gt; []);
 366    ///
 367    ///     // The Syringe built inside this scope sees only MyTool, even if other [AgentFunction]
 368    ///     // types are registered globally by the [ModuleInitializer].
 369    /// }
 370    /// </code>
 371    /// </example>
 372    /// </remarks>
 373    public static IDisposable BeginTestScope(
 374        Func<IReadOnlyList<Type>> functionTypes,
 375        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> groupTypes,
 376        Func<IReadOnlyList<Type>> agentTypes,
 377        Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>>? handoffTopology = null
 378        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? groupChatGroups = null,
 379        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>>? sequentialTopology = null,
 380        IAIFunctionProvider? aiFunctionProvider = null)
 381    {
 13382        handoffTopology ??= static () => new Dictionary<Type, IReadOnlyList<(Type, string?)>>();
 13383        groupChatGroups ??= static () => new Dictionary<string, IReadOnlyList<Type>>();
 13384        sequentialTopology ??= static () => new Dictionary<string, IReadOnlyList<Type>>();
 13385        var prior = _asyncLocalOverride.Value;
 13386        var priorProvider = _asyncLocalProviderOverride.Value;
 13387        var priorGraphTopology = _asyncLocalGraphTopologyOverride.Value;
 13388        _asyncLocalOverride.Value = new Registration(functionTypes, groupTypes, agentTypes, handoffTopology, groupChatGr
 13389        _asyncLocalProviderOverride.Value = aiFunctionProvider;
 13390        _asyncLocalGraphTopologyOverride.Value = null;
 13391        return new Scope(prior, priorProvider, priorGraphTopology);
 392    }
 393
 394    private static void EnsureCombined()
 395    {
 533396        if (_cachedCombined.HasValue)
 531397            return;
 398
 4399        var functionProviders = _registrations.Select(r => r.FunctionTypes).ToArray();
 4400        var groupProviders = _registrations.Select(r => r.GroupTypes).ToArray();
 4401        var agentProviders = _registrations.Select(r => r.AgentTypes).ToArray();
 4402        var topologyProviders = _registrations.Select(r => r.HandoffTopology).ToArray();
 4403        var groupChatProviders = _registrations.Select(r => r.GroupChatGroups).ToArray();
 4404        var sequentialProviders = _registrations.Select(r => r.SequentialTopology).ToArray();
 405
 2406        Func<IReadOnlyList<Type>> combinedFunctions = () =>
 2407        {
 179408            var result = new List<Type>();
 179409            var seen = new HashSet<Type>();
 716410            foreach (var p in functionProviders)
 358411                foreach (var t in p())
 0412                    if (seen.Add(t))
 0413                        result.Add(t);
 179414            return result;
 2415        };
 416
 2417        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> combinedGroups = () =>
 2418        {
 206419            var merged = new Dictionary<string, List<Type>>();
 824420            foreach (var p in groupProviders)
 412421                foreach (var (key, types) in p())
 2422                {
 0423                    if (!merged.TryGetValue(key, out var list))
 0424                        merged[key] = list = [];
 0425                    foreach (var t in types)
 0426                        if (!list.Contains(t))
 0427                            list.Add(t);
 2428                }
 206429            return merged.ToDictionary(
 0430                kv => kv.Key,
 206431                kv => (IReadOnlyList<Type>)kv.Value.AsReadOnly());
 2432        };
 433
 2434        Func<IReadOnlyList<Type>> combinedAgents = () =>
 2435        {
 124436            var result = new List<Type>();
 124437            var seen = new HashSet<Type>();
 496438            foreach (var p in agentProviders)
 248439                foreach (var t in p())
 0440                    if (seen.Add(t))
 0441                        result.Add(t);
 124442            return result;
 2443        };
 444
 2445        Func<IReadOnlyDictionary<Type, IReadOnlyList<(Type TargetType, string? HandoffReason)>>> combinedTopology = () =
 2446        {
 6447            var merged = new Dictionary<Type, List<(Type, string?)>>();
 24448            foreach (var p in topologyProviders)
 12449                foreach (var (agentType, targets) in p())
 2450                {
 0451                    if (!merged.TryGetValue(agentType, out var list))
 0452                        merged[agentType] = list = [];
 0453                    foreach (var target in targets)
 0454                        if (!list.Contains(target))
 0455                            list.Add(target);
 2456                }
 6457            return merged.ToDictionary(
 0458                kv => kv.Key,
 6459                kv => (IReadOnlyList<(Type, string?)>)kv.Value.AsReadOnly());
 2460        };
 461
 2462        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> combinedGroupChatGroups = () =>
 2463        {
 13464            var merged = new Dictionary<string, List<Type>>();
 52465            foreach (var p in groupChatProviders)
 26466                foreach (var (key, types) in p())
 2467                {
 0468                    if (!merged.TryGetValue(key, out var list))
 0469                        merged[key] = list = [];
 0470                    foreach (var t in types)
 0471                        if (!list.Contains(t))
 0472                            list.Add(t);
 2473                }
 13474            return merged.ToDictionary(
 0475                kv => kv.Key,
 13476                kv => (IReadOnlyList<Type>)kv.Value.AsReadOnly());
 2477        };
 478
 2479        Func<IReadOnlyDictionary<string, IReadOnlyList<Type>>> combinedSequentialTopology = () =>
 2480        {
 5481            var merged = new Dictionary<string, List<Type>>();
 20482            foreach (var p in sequentialProviders)
 10483                foreach (var (key, types) in p())
 2484                {
 0485                    if (!merged.TryGetValue(key, out var list))
 0486                        merged[key] = list = [];
 0487                    foreach (var t in types)
 0488                        if (!list.Contains(t))
 0489                            list.Add(t);
 2490                }
 5491            return merged.ToDictionary(
 0492                kv => kv.Key,
 5493                kv => (IReadOnlyList<Type>)kv.Value.AsReadOnly());
 2494        };
 495
 2496        _cachedCombined = (combinedFunctions, combinedGroups, combinedAgents, combinedTopology, combinedGroupChatGroups,
 2497    }
 498
 499    private static void EnsureCombinedGraphTopology()
 500    {
 0501        if (_cachedCombinedGraphTopology is not null)
 0502            return;
 503
 0504        var providers = _graphTopologyRegistrations.ToArray();
 0505        _cachedCombinedGraphTopology = () =>
 0506        {
 0507            var merged = new Dictionary<string, GraphTopologyRegistration>(StringComparer.Ordinal);
 0508            foreach (var p in providers)
 0509                foreach (var (name, reg) in p())
 0510                    merged[name] = reg;
 0511            return merged;
 0512        };
 0513    }
 514
 515    private sealed class Scope : IDisposable
 516    {
 517        private readonly Registration? _prior;
 518        private readonly IAIFunctionProvider? _priorProvider;
 519        private readonly Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>? _priorGraphTopology;
 520
 13521        public Scope(
 13522            Registration? prior,
 13523            IAIFunctionProvider? priorProvider,
 13524            Func<IReadOnlyDictionary<string, GraphTopologyRegistration>>? priorGraphTopology)
 525        {
 13526            _prior = prior;
 13527            _priorProvider = priorProvider;
 13528            _priorGraphTopology = priorGraphTopology;
 13529        }
 530
 531        public void Dispose()
 532        {
 13533            _asyncLocalOverride.Value = _prior;
 13534            _asyncLocalProviderOverride.Value = _priorProvider;
 13535            _asyncLocalGraphTopologyOverride.Value = _priorGraphTopology;
 13536        }
 537    }
 538}
Generated by: ReportGenerator 5.5.10.0
06/18/2026 - 05:53:46
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.Type,System.Collections.Generic.IReadOnlyList`1<System.ValueTuple`2<System.Type,System.String>>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>)
get_FunctionTypes()
get_GroupTypes()
get_AgentTypes()
get_HandoffTopology()
get_GroupChatGroups()
get_SequentialTopology()
.cctor()
RegisterAIFunctionProvider(NexusLabs.Needlr.AgentFramework.IAIFunctionProvider)
TryGetAIFunctionProvider(NexusLabs.Needlr.AgentFramework.IAIFunctionProvider&)
RegisterGraphTopology(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,NexusLabs.Needlr.AgentFramework.GraphTopologyRegistration>>)
TryGetGraphTopology(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,NexusLabs.Needlr.AgentFramework.GraphTopologyRegistration>>&)
Register(System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.Type,System.Collections.Generic.IReadOnlyList`1<System.ValueTuple`2<System.Type,System.String>>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>)
TryGetFunctionTypes(System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>&)
TryGetGroupTypes(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>&)
TryGetAgentTypes(System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>&)
TryGetHandoffTopology(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.Type,System.Collections.Generic.IReadOnlyList`1<System.ValueTuple`2<System.Type,System.String>>>>&)
TryGetGroupChatGroups(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>&)
TryGetSequentialTopology(System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>&)
BeginTestScope(System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyList`1<System.Type>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.Type,System.Collections.Generic.IReadOnlyList`1<System.ValueTuple`2<System.Type,System.String>>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.Collections.Generic.IReadOnlyList`1<System.Type>>>,NexusLabs.Needlr.AgentFramework.IAIFunctionProvider)
EnsureCombined()
EnsureCombinedGraphTopology()
.ctor(NexusLabs.Needlr.AgentFramework.AgentFrameworkGeneratedBootstrap/Registration,NexusLabs.Needlr.AgentFramework.IAIFunctionProvider,System.Func`1<System.Collections.Generic.IReadOnlyDictionary`2<System.String,NexusLabs.Needlr.AgentFramework.GraphTopologyRegistration>>)
Dispose()