Foundgine.Runtime 2.2.1

dotnet add package Foundgine.Runtime --version 2.2.1
                    
NuGet\Install-Package Foundgine.Runtime -Version 2.2.1
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Foundgine.Runtime" Version="2.2.1" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Foundgine.Runtime" Version="2.2.1" />
                    
Directory.Packages.props
<PackageReference Include="Foundgine.Runtime" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Foundgine.Runtime --version 2.2.1
                    
#r "nuget: Foundgine.Runtime, 2.2.1"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Foundgine.Runtime@2.2.1
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Foundgine.Runtime&version=2.2.1
                    
Install as a Cake Addin
#tool nuget:?package=Foundgine.Runtime&version=2.2.1
                    
Install as a Cake Tool

Foundgine.Runtime

Purpose

Foundgine.Runtime is the application-facing execution boundary of Foundgine v2. It turns resolved semantic intent into controlled execution while keeping authorization, planning, approvals, routing, and execution policy outside individual providers.

Small application-facing surface

A normal application should need very little of the runtime API. Optional capabilities are opt-in; plain Foundgine does not enable grounding, graph retrieval, high assurance, audit evidence, or any other optional capability unless the application explicitly configures it:

services.AddFoundgine(model, authorizationPolicy);

// Or discover the semantic model from structural metadata:
services.AddFoundgine(options =>
{
    options.UseMetadata(metadata);
});

// Resolve through DI
IFoundgineExecutor foundgine = ...;
var result = await foundgine.ExecuteAsync(request);

Start with IFoundgineExecutor, which intentionally exposes only the two ExecuteAsync overloads. Use the full IFoundgine interface only when you need capability discovery, dry-run or approval workflows. Dry-run/approval, mutation, discovery, routing and control-plane APIs are advanced surfaces; they are available when a scenario needs them, but they are not prerequisites for basic execution.

Provider authors normally work against the contracts in Foundgine.Core.Execution (IExecutionProvider, IProviderPlanCompiler, and related provider-neutral plan types) rather than runtime internals.

What this package provides

  • IFoundgineExecutor as the minimal two-method execution surface, plus the full IFoundgine and mutation APIs for advanced workflows.
  • Foundgine read/query and mutation orchestration.
  • Dependency-injection registration and runtime options.
  • Semantic resolution-to-plan execution coordination.
  • Plan approval, dry-run and runtime src/csharp/security/resource validation.
  • Provider dispatch and execution orchestration over contracts defined in Foundgine.Core.Execution.
  • Task routing.
  • Control-plane facilities for authority recovery and AI-agent tool-call governance, including registry, risk/policy checks, approvals and audit-related contracts.

What it does not provide

Foundgine.Runtime is not a storage provider and does not host GraphQL or MCP. It also does not supply an LLM client. Concrete integrations are supplied by Foundgine.Providers and Foundgine.Extensions.

What is expected from the consumer

The application must compose a semantic model, authorization/security policy and one or more concrete providers. Register the runtime through dependency injection and configure the policies appropriate to the application. The runtime is responsible for enforcing the execution boundary; it does not invent your domain model or storage configuration.

Install

dotnet add package Foundgine.Runtime --version 2.0.3

Typical relationship

Foundgine.Core → Foundgine.Runtime → provider/integration packages. Most applications will use Foundgine.Runtime together with Foundgine.Providers rather than using the runtime alone.

Product Compatible and additional computed target framework versions.
.NET net9.0 is compatible.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 was computed.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (2)

Showing the top 2 NuGet packages that depend on Foundgine.Runtime:

Package Downloads
Foundgine.Providers

Foundgine.Providers contains the concrete provider and integration implementations for Foundgine v2. It includes storage providers and adapters, AI/model and MCP tooling integrations, and Elasticsearch and vector-store support. It also carries the Foundgine AOT source generator as a build-time analyzer inside the NuGet package, so consumers do not install a separate generator package and the generator is not a runtime dependency. Foundgine.Providers depends only on Foundgine.Core and Foundgine.Runtime; secure GraphQL/Hot Chocolate execution lives in Foundgine.Extensions alongside GraphQL translation. Consumers are expected to choose and configure the provider(s) matching their application and supply the semantic model and runtime configuration required by Foundgine.

Foundgine.Extensions

Foundgine.Extensions contains optional framework integrations for Foundgine v2. The current package provides the Hot Chocolate GraphQL integration: translating GraphQL operations into Foundgine semantic intent, and the secure query/mutation executors that run that intent through the Foundgine authorization/execution boundary. It does not replace the Foundgine execution/runtime layer and does not provide storage providers. Consumers are expected to have Foundgine.Core and Foundgine.Runtime installed and to configure their GraphQL server and semantic model; concrete storage/AI/MCP provider execution is supplied separately by Foundgine.Providers.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
2.2.1 106 9/14/2026
2.2.0 116 9/13/2026

2.0.0: v2 package restructuring. Consolidates the former Foundgine (root orchestrator), Foundgine.Execution, and Foundgine.Security.Authority packages.