Rewrite ParameterProvider and its usage to make sure it's invoked at the INVOKE phase

reakaleek · reakaleek · commit 37f32ef9e990 · 2025-08-01T13:22:09.000+02:00
the ssm parameter lambda exention does not work at INIT time
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/Adapters/AskAi/LlmGatewayAskAiGateway.cs b/src/api/Elastic.Documentation.Api.Infrastructure/Adapters/AskAi/LlmGatewayAskAiGateway.cs
@@ -7,21 +7,20 @@
 using System.Text.Json.Serialization;
 using Elastic.Documentation.Api.Core.AskAi;
 using Elastic.Documentation.Api.Infrastructure.Gcp;
-using Microsoft.Extensions.Options;
 
 namespace Elastic.Documentation.Api.Infrastructure.Adapters.AskAi;
 
-public class LlmGatewayAskAiGateway(HttpClient httpClient, GcpIdTokenProvider tokenProvider, IOptionsSnapshot<LlmGatewayOptions> options) : IAskAiGateway<Stream>
+public class LlmGatewayAskAiGateway(HttpClient httpClient, GcpIdTokenProvider tokenProvider, LlmGatewayOptions options) : IAskAiGateway<Stream>
 {
 	public async Task<Stream> AskAi(AskAiRequest askAiRequest, Cancel ctx = default)
 	{
 		var llmGatewayRequest = LlmGatewayRequest.CreateFromRequest(askAiRequest);
 		var requestBody = JsonSerializer.Serialize(llmGatewayRequest, LlmGatewayContext.Default.LlmGatewayRequest);
-		var request = new HttpRequestMessage(HttpMethod.Post, options.Value.FunctionUrl)
+		var request = new HttpRequestMessage(HttpMethod.Post, options.FunctionUrl)
 		{
 			Content = new StringContent(requestBody, Encoding.UTF8, "application/json")
 		};
-		var authToken = await tokenProvider.GenerateIdTokenAsync(ctx);
+		var authToken = await tokenProvider.GenerateIdTokenAsync(options.ServiceAccount, options.TargetAudience, ctx);
 		request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken);
 		request.Headers.Add("User-Agent", "elastic-docs-proxy/1.0");
 		request.Headers.Add("Accept", "text/event-stream");
@@ -44,7 +43,7 @@ public static LlmGatewayRequest CreateFromRequest(AskAiRequest request) =>
 			PlatformContext: new PlatformContext("support_portal", "support_assistant", []),
 			Input:
 			[
-				new ChatInput("system", AskAiRequest.SystemPrompt),
+				new ChatInput("user", AskAiRequest.SystemPrompt),
 				new ChatInput("user", request.Message)
 			],
 			ThreadId: request.ThreadId ?? "elastic-docs-" + Guid.NewGuid()
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/Adapters/AskAi/LlmGatewayOptions.cs b/src/api/Elastic.Documentation.Api.Infrastructure/Adapters/AskAi/LlmGatewayOptions.cs
@@ -0,0 +1,22 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using Elastic.Documentation.Api.Infrastructure.Aws;
+
+namespace Elastic.Documentation.Api.Infrastructure.Adapters.AskAi;
+
+public class LlmGatewayOptions
+{
+	public LlmGatewayOptions(IParameterProvider parameterProvider)
+	{
+		ServiceAccount = parameterProvider.GetParam("llm-gateway-service-account").GetAwaiter().GetResult();
+		FunctionUrl = parameterProvider.GetParam("llm-gateway-function-url").GetAwaiter().GetResult();
+		var uri = new Uri(FunctionUrl);
+		TargetAudience = $"{uri.Scheme}://{uri.Host}";
+	}
+
+	public string ServiceAccount { get; }
+	public string FunctionUrl { get; }
+	public string TargetAudience { get; }
+}
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/Aws/LambdaExtensionParameterProvider.cs b/src/api/Elastic.Documentation.Api.Infrastructure/Aws/LambdaExtensionParameterProvider.cs
@@ -9,7 +9,7 @@
 
 namespace Elastic.Documentation.Api.Infrastructure.Aws;
 
-public class LambdaExtensionParameterProvider(IHttpClientFactory httpClientFactory, ILogger<LambdaExtensionParameterProvider> logger) : IParameterProvider
+public class LambdaExtensionParameterProvider(IHttpClientFactory httpClientFactory, AppEnvironment appEnvironment, ILogger<LambdaExtensionParameterProvider> logger) : IParameterProvider
 {
 	public const string HttpClientName = "AwsParametersAndSecretsLambdaExtensionClient";
 	private readonly HttpClient _httpClient = httpClientFactory.CreateClient(HttpClientName);
@@ -18,8 +18,10 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc
 	{
 		try
 		{
-			logger.LogInformation("Retrieving parameter '{Name}' from Lambda Extension (SSM Parameter Store).", name);
-			var response = await _httpClient.GetFromJsonAsync<ParameterResponse>($"/systemsmanager/parameters/get?name={Uri.EscapeDataString(name)}&withDecryption={withDecryption.ToString().ToLowerInvariant()}", AwsJsonContext.Default.ParameterResponse, ctx);
+			var prefix = $"/elastic-docs-v3/{appEnvironment.Current.ToStringFast(true)}/";
+			var prefixedName = prefix + name.TrimStart('/');
+			logger.LogInformation("Retrieving parameter '{Name}' from Lambda Extension (SSM Parameter Store).", prefixedName);
+			var response = await _httpClient.GetFromJsonAsync<ParameterResponse>($"/systemsmanager/parameters/get?name={Uri.EscapeDataString(prefixedName)}&withDecryption={withDecryption.ToString().ToLowerInvariant()}", AwsJsonContext.Default.ParameterResponse, ctx);
 			return response?.Parameter?.Value ?? throw new InvalidOperationException($"Parameter value for '{name}' is null.");
 		}
 		catch (HttpRequestException httpEx)
@@ -42,23 +44,23 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc
 
 internal sealed class ParameterResponse
 {
-	public Parameter? Parameter { get; set; }
+	public required Parameter Parameter { get; set; }
 }
 
 internal sealed class Parameter
 {
-	public string? Arn { get; set; }
-	public string? Name { get; set; }
-	public string? Type { get; set; }
-	public string? Value { get; set; }
-	public string? Version { get; set; }
+	[JsonPropertyName("ARN")]
+	public required string Arn { get; set; }
+	public required string Name { get; set; }
+	public required string Type { get; set; }
+	public required string Value { get; set; }
+	public required int Version { get; set; }
 	public string? Selector { get; set; }
-	public string? LastModifiedDate { get; set; }
-	public string? LastModifiedUser { get; set; }
-	public string? DataType { get; set; }
+	public DateTime LastModifiedDate { get; set; }
+	public required string DataType { get; set; }
 }
 
 
 [JsonSerializable(typeof(ParameterResponse))]
-[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.Unspecified)]
 internal sealed partial class AwsJsonContext : JsonSerializerContext;
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/Aws/LocalParameterProvider.cs b/src/api/Elastic.Documentation.Api.Infrastructure/Aws/LocalParameterProvider.cs
@@ -10,7 +10,7 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc
 	{
 		switch (name)
 		{
-			case "/elastic-docs-v3/dev/llm-gateway-service-account":
+			case "llm-gateway-service-account":
 				{
 					const string envName = "LLM_GATEWAY_SERVICE_ACCOUNT_KEY_PATH";
 					var serviceAccountKeyPath = Environment.GetEnvironmentVariable(envName);
@@ -21,7 +21,7 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc
 					var serviceAccountKey = await File.ReadAllTextAsync(serviceAccountKeyPath, ctx);
 					return serviceAccountKey;
 				}
-			case "/elastic-docs-v3/dev/llm-gateway-function-url":
+			case "llm-gateway-function-url":
 				{
 					const string envName = "LLM_GATEWAY_FUNCTION_URL";
 					var value = Environment.GetEnvironmentVariable(envName);
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/Gcp/GcpIdTokenProvider.cs b/src/api/Elastic.Documentation.Api.Infrastructure/Gcp/GcpIdTokenProvider.cs
@@ -6,33 +6,35 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using Elastic.Documentation.Api.Infrastructure.Aws;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
 
 namespace Elastic.Documentation.Api.Infrastructure.Gcp;
 
 // This is a custom implementation to create an ID token for GCP.
 // Because Google.Api.Auth.OAuth2 is not compatible with AOT
-public class GcpIdTokenProvider(HttpClient httpClient, IOptionsSnapshot<LlmGatewayOptions> options)
+public class GcpIdTokenProvider(HttpClient httpClient)
 {
-	public async Task<string> GenerateIdTokenAsync(Cancel cancellationToken = default)
+	public async Task<string> GenerateIdTokenAsync(string serviceAccount, string targetAudience, Cancel cancellationToken = default)
 	{
 		// Read and parse service account key file using System.Text.Json source generation (AOT compatible)
-		var serviceAccount = JsonSerializer.Deserialize(options.Value.ServiceAccount, GcpJsonContext.Default.ServiceAccountKey);
+		var serviceAccountJson = JsonSerializer.Deserialize(serviceAccount, GcpJsonContext.Default.ServiceAccountKey);
 
 		// Create JWT header
-		var header = new JwtHeader("RS256", "JWT", serviceAccount.PrivateKeyId);
+		var header = new JwtHeader("RS256", "JWT", serviceAccountJson.PrivateKeyId);
 		var headerJson = JsonSerializer.Serialize(header, JwtHeaderJsonContext.Default.JwtHeader);
 		var headerBase64 = Base64UrlEncode(Encoding.UTF8.GetBytes(headerJson));
 
 		// Create JWT payload
 		var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
 		var payload = new JwtPayload(
-			serviceAccount.ClientEmail,
-			serviceAccount.ClientEmail,
+			serviceAccountJson.ClientEmail,
+			serviceAccountJson.ClientEmail,
 			"https://oauth2.googleapis.com/token",
 			now,
 			now + 300, // 5 minutes
-			options.Value.TargetAudience
+			targetAudience
 		);
 
 		var payloadJson = JsonSerializer.Serialize(payload, GcpJsonContext.Default.JwtPayload);
@@ -43,7 +45,7 @@ public async Task<string> GenerateIdTokenAsync(Cancel cancellationToken = defaul
 		var messageBytes = Encoding.UTF8.GetBytes(message);
 
 		// Parse the private key (removing PEM headers/footers and decoding)
-		var privateKeyPem = serviceAccount.PrivateKey
+		var privateKeyPem = serviceAccountJson.PrivateKey
 			.Replace("-----BEGIN PRIVATE KEY-----", "")
 			.Replace("-----END PRIVATE KEY-----", "")
 			.Replace("\n", "")
@@ -59,7 +61,7 @@ public async Task<string> GenerateIdTokenAsync(Cancel cancellationToken = defaul
 		var jwt = $"{message}.{signatureBase64}";
 
 		// Exchange JWT for ID token
-		return await ExchangeJwtForIdToken(jwt, options.Value.TargetAudience, cancellationToken);
+		return await ExchangeJwtForIdToken(jwt, targetAudience, cancellationToken);
 	}
 
 
diff --git a/src/api/Elastic.Documentation.Api.Infrastructure/ServicesExtension.cs b/src/api/Elastic.Documentation.Api.Infrastructure/ServicesExtension.cs
@@ -15,19 +15,17 @@
 namespace Elastic.Documentation.Api.Infrastructure;
 
 [EnumExtensions]
-public enum AppEnvironment
+public enum AppEnv
 {
 	[Display(Name = "dev")] Dev,
 	[Display(Name = "staging")] Staging,
 	[Display(Name = "edge")] Edge,
 	[Display(Name = "prod")] Prod
 }
 
-public class LlmGatewayOptions
+public class AppEnvironment
 {
-	public string ServiceAccount { get; set; } = string.Empty;
-	public string FunctionUrl { get; set; } = string.Empty;
-	public string TargetAudience { get; set; } = string.Empty;
+	public AppEnv Current { get; init; }
 }
 
 public static class ServicesExtension
@@ -41,42 +39,44 @@ public static class ServicesExtension
 
 	public static void AddElasticDocsApiUsecases(this IServiceCollection services, string? appEnvironment)
 	{
-		if (AppEnvironmentExtensions.TryParse(appEnvironment, out var parsedEnvironment, true))
+		if (AppEnvExtensions.TryParse(appEnvironment, out var parsedEnvironment, true))
 		{
 			AddElasticDocsApiUsecases(services, parsedEnvironment);
 		}
 		else
 		{
 			var logger = GetLogger(services);
 			logger?.LogWarning("Unable to parse environment {AppEnvironment} into AppEnvironment. Using default AppEnvironment.Dev", appEnvironment);
-			AddElasticDocsApiUsecases(services, AppEnvironment.Dev);
+			AddElasticDocsApiUsecases(services, AppEnv.Dev);
 		}
 	}
 
 
-	private static void AddElasticDocsApiUsecases(this IServiceCollection services, AppEnvironment appEnvironment)
+	private static void AddElasticDocsApiUsecases(this IServiceCollection services, AppEnv appEnv)
 	{
 		_ = services.ConfigureHttpJsonOptions(options =>
 		{
 			options.SerializerOptions.TypeInfoResolverChain.Insert(0, ApiJsonContext.Default);
 		});
 		_ = services.AddHttpClient();
-		AddParameterProvider(services, appEnvironment);
-		AddAskAiUsecase(services, appEnvironment);
+		// Register AppEnvironment as a singleton for dependency injection
+		_ = services.AddSingleton(new AppEnvironment { Current = appEnv });
+		AddParameterProvider(services, appEnv);
+		AddAskAiUsecase(services, appEnv);
 	}
 
-	// https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html
-	private static void AddParameterProvider(IServiceCollection services, AppEnvironment appEnvironment)
+	// https://docs.aws.amazon.com/systems	-manager/latest/userguide/ps-integration-lambda-extensions.html
+	private static void AddParameterProvider(IServiceCollection services, AppEnv appEnv)
 	{
 		var logger = GetLogger(services);
 
-		switch (appEnvironment)
+		switch (appEnv)
 		{
-			case AppEnvironment.Prod:
-			case AppEnvironment.Staging:
-			case AppEnvironment.Edge:
+			case AppEnv.Prod:
+			case AppEnv.Staging:
+			case AppEnv.Edge:
 				{
-					logger?.LogInformation("Configuring LambdaExtensionParameterProvider for environment {AppEnvironment}", appEnvironment);
+					logger?.LogInformation("Configuring LambdaExtensionParameterProvider for environment {AppEnvironment}", appEnv);
 					_ = services.AddHttpClient(LambdaExtensionParameterProvider.HttpClientName, client =>
 					{
 						client.BaseAddress = new Uri("http://localhost:2773");
@@ -85,39 +85,27 @@ private static void AddParameterProvider(IServiceCollection services, AppEnviron
 					_ = services.AddSingleton<IParameterProvider, LambdaExtensionParameterProvider>();
 					break;
 				}
-			case AppEnvironment.Dev:
+			case AppEnv.Dev:
 				{
-					logger?.LogInformation("Configuring LocalParameterProvider for environment {AppEnvironment}", appEnvironment);
+					logger?.LogInformation("Configuring LocalParameterProvider for environment {AppEnvironment}", appEnv);
 					_ = services.AddSingleton<IParameterProvider, LocalParameterProvider>();
 					break;
 				}
 			default:
 				{
-					throw new ArgumentOutOfRangeException(nameof(appEnvironment), appEnvironment,
+					throw new ArgumentOutOfRangeException(nameof(appEnv), appEnv,
 						"Unsupported environment for parameter provider.");
 				}
 		}
 	}
 
-	private static void AddAskAiUsecase(IServiceCollection services, AppEnvironment appEnvironment)
+	private static void AddAskAiUsecase(IServiceCollection services, AppEnv appEnv)
 	{
 		var logger = GetLogger(services);
-		logger?.LogInformation("Configuring AskAi use case for environment {AppEnvironment}", appEnvironment);
-
-		_ = services.Configure<LlmGatewayOptions>(options =>
-		{
-			var serviceProvider = services.BuildServiceProvider();
-			var parameterProvider = serviceProvider.GetRequiredService<IParameterProvider>();
-			var appEnvString = appEnvironment.ToStringFast(true);
-
-			options.ServiceAccount = parameterProvider.GetParam($"/elastic-docs-v3/{appEnvString}/llm-gateway-service-account").GetAwaiter().GetResult();
-			options.FunctionUrl = parameterProvider.GetParam($"/elastic-docs-v3/{appEnvString}/llm-gateway-function-url").GetAwaiter().GetResult();
-
-			var functionUri = new Uri(options.FunctionUrl);
-			options.TargetAudience = $"{functionUri.Scheme}://{functionUri.Host}";
-		});
-		_ = services.AddScoped<GcpIdTokenProvider>();
-		_ = services.AddScoped<IAskAiGateway<Stream>, LlmGatewayAskAiGateway>();
+		logger?.LogInformation("Configuring AskAi use case for environment {AppEnvironment}", appEnv);
+		_ = services.AddSingleton<GcpIdTokenProvider>();
+		_ = services.AddSingleton<IAskAiGateway<Stream>, LlmGatewayAskAiGateway>();
+		_ = services.AddScoped<LlmGatewayOptions>();
 		_ = services.AddScoped<AskAiUsecase>();
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc`
`10`	`10`	`{`
`11`	`11`	`switch (name)`
`12`	`12`	`{`
`13`		`- case "/elastic-docs-v3/dev/llm-gateway-service-account":`
	`13`	`+ case "llm-gateway-service-account":`
`14`	`14`	`{`
`15`	`15`	`const string envName = "LLM_GATEWAY_SERVICE_ACCOUNT_KEY_PATH";`
`16`	`16`	`var serviceAccountKeyPath = Environment.GetEnvironmentVariable(envName);`
`@@ -21,7 +21,7 @@ public async Task<string> GetParam(string name, bool withDecryption = true, Canc`
`21`	`21`	`var serviceAccountKey = await File.ReadAllTextAsync(serviceAccountKeyPath, ctx);`
`22`	`22`	`return serviceAccountKey;`
`23`	`23`	`}`
`24`		`- case "/elastic-docs-v3/dev/llm-gateway-function-url":`
	`24`	`+ case "llm-gateway-function-url":`
`25`	`25`	`{`
`26`	`26`	`const string envName = "LLM_GATEWAY_FUNCTION_URL";`
`27`	`27`	`var value = Environment.GetEnvironmentVariable(envName);`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,17 @@`
`15`	`15`	`namespace Elastic.Documentation.Api.Infrastructure;`
`16`	`16`
`17`	`17`	`[EnumExtensions]`
`18`		`-public enum AppEnvironment`
	`18`	`+public enum AppEnv`
`19`	`19`	`{`
`20`	`20`	`[Display(Name = "dev")] Dev,`
`21`	`21`	`[Display(Name = "staging")] Staging,`
`22`	`22`	`[Display(Name = "edge")] Edge,`
`23`	`23`	`[Display(Name = "prod")] Prod`
`24`	`24`	`}`
`25`	`25`
`26`		`-public class LlmGatewayOptions`
	`26`	`+public class AppEnvironment`
`27`	`27`	`{`
`28`		`- public string ServiceAccount { get; set; } = string.Empty;`
`29`		`- public string FunctionUrl { get; set; } = string.Empty;`
`30`		`- public string TargetAudience { get; set; } = string.Empty;`
	`28`	`+ public AppEnv Current { get; init; }`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`public static class ServicesExtension`
`@@ -41,42 +39,44 @@ public static class ServicesExtension`
`41`	`39`
`42`	`40`	`public static void AddElasticDocsApiUsecases(this IServiceCollection services, string? appEnvironment)`
`43`	`41`	`{`
`44`		`- if (AppEnvironmentExtensions.TryParse(appEnvironment, out var parsedEnvironment, true))`
	`42`	`+ if (AppEnvExtensions.TryParse(appEnvironment, out var parsedEnvironment, true))`
`45`	`43`	`{`
`46`	`44`	`AddElasticDocsApiUsecases(services, parsedEnvironment);`
`47`	`45`	`}`
`48`	`46`	`else`
`49`	`47`	`{`
`50`	`48`	`var logger = GetLogger(services);`
`51`	`49`	`logger?.LogWarning("Unable to parse environment {AppEnvironment} into AppEnvironment. Using default AppEnvironment.Dev", appEnvironment);`
`52`		`- AddElasticDocsApiUsecases(services, AppEnvironment.Dev);`
	`50`	`+ AddElasticDocsApiUsecases(services, AppEnv.Dev);`
`53`	`51`	`}`
`54`	`52`	`}`
`55`	`53`
`56`	`54`
`57`		`- private static void AddElasticDocsApiUsecases(this IServiceCollection services, AppEnvironment appEnvironment)`
	`55`	`+ private static void AddElasticDocsApiUsecases(this IServiceCollection services, AppEnv appEnv)`
`58`	`56`	`{`
`59`	`57`	`_ = services.ConfigureHttpJsonOptions(options =>`
`60`	`58`	`{`
`61`	`59`	`options.SerializerOptions.TypeInfoResolverChain.Insert(0, ApiJsonContext.Default);`
`62`	`60`	`});`
`63`	`61`	`_ = services.AddHttpClient();`
`64`		`- AddParameterProvider(services, appEnvironment);`
`65`		`- AddAskAiUsecase(services, appEnvironment);`
	`62`	`+ // Register AppEnvironment as a singleton for dependency injection`
	`63`	`+ _ = services.AddSingleton(new AppEnvironment { Current = appEnv });`
	`64`	`+ AddParameterProvider(services, appEnv);`
	`65`	`+ AddAskAiUsecase(services, appEnv);`
`66`	`66`	`}`
`67`	`67`
`68`		`- // https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html`
`69`		`- private static void AddParameterProvider(IServiceCollection services, AppEnvironment appEnvironment)`
	`68`	`+ // https://docs.aws.amazon.com/systems -manager/latest/userguide/ps-integration-lambda-extensions.html`
	`69`	`+ private static void AddParameterProvider(IServiceCollection services, AppEnv appEnv)`
`70`	`70`	`{`
`71`	`71`	`var logger = GetLogger(services);`
`72`	`72`
`73`		`- switch (appEnvironment)`
	`73`	`+ switch (appEnv)`
`74`	`74`	`{`
`75`		`- case AppEnvironment.Prod:`
`76`		`- case AppEnvironment.Staging:`
`77`		`- case AppEnvironment.Edge:`
	`75`	`+ case AppEnv.Prod:`
	`76`	`+ case AppEnv.Staging:`
	`77`	`+ case AppEnv.Edge:`
`78`	`78`	`{`
`79`		`- logger?.LogInformation("Configuring LambdaExtensionParameterProvider for environment {AppEnvironment}", appEnvironment);`
	`79`	`+ logger?.LogInformation("Configuring LambdaExtensionParameterProvider for environment {AppEnvironment}", appEnv);`
`80`	`80`	`_ = services.AddHttpClient(LambdaExtensionParameterProvider.HttpClientName, client =>`
`81`	`81`	`{`
`82`	`82`	`client.BaseAddress = new Uri("http://localhost:2773");`
`@@ -85,39 +85,27 @@ private static void AddParameterProvider(IServiceCollection services, AppEnviron`
`85`	`85`	`_ = services.AddSingleton<IParameterProvider, LambdaExtensionParameterProvider>();`
`86`	`86`	`break;`
`87`	`87`	`}`
`88`		`- case AppEnvironment.Dev:`
	`88`	`+ case AppEnv.Dev:`
`89`	`89`	`{`
`90`		`- logger?.LogInformation("Configuring LocalParameterProvider for environment {AppEnvironment}", appEnvironment);`
	`90`	`+ logger?.LogInformation("Configuring LocalParameterProvider for environment {AppEnvironment}", appEnv);`
`91`	`91`	`_ = services.AddSingleton<IParameterProvider, LocalParameterProvider>();`
`92`	`92`	`break;`
`93`	`93`	`}`
`94`	`94`	`default:`
`95`	`95`	`{`
`96`		`- throw new ArgumentOutOfRangeException(nameof(appEnvironment), appEnvironment,`
	`96`	`+ throw new ArgumentOutOfRangeException(nameof(appEnv), appEnv,`
`97`	`97`	`"Unsupported environment for parameter provider.");`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`- private static void AddAskAiUsecase(IServiceCollection services, AppEnvironment appEnvironment)`
	`102`	`+ private static void AddAskAiUsecase(IServiceCollection services, AppEnv appEnv)`
`103`	`103`	`{`
`104`	`104`	`var logger = GetLogger(services);`
`105`		`- logger?.LogInformation("Configuring AskAi use case for environment {AppEnvironment}", appEnvironment);`
`106`		`-`
`107`		`- _ = services.Configure<LlmGatewayOptions>(options =>`
`108`		`- {`
`109`		`- var serviceProvider = services.BuildServiceProvider();`
`110`		`- var parameterProvider = serviceProvider.GetRequiredService<IParameterProvider>();`
`111`		`- var appEnvString = appEnvironment.ToStringFast(true);`
`112`		`-`
`113`		`- options.ServiceAccount = parameterProvider.GetParam($"/elastic-docs-v3/{appEnvString}/llm-gateway-service-account").GetAwaiter().GetResult();`
`114`		`- options.FunctionUrl = parameterProvider.GetParam($"/elastic-docs-v3/{appEnvString}/llm-gateway-function-url").GetAwaiter().GetResult();`
`115`		`-`
`116`		`- var functionUri = new Uri(options.FunctionUrl);`
`117`		`- options.TargetAudience = $"{functionUri.Scheme}://{functionUri.Host}";`
`118`		`- });`
`119`		`- _ = services.AddScoped<GcpIdTokenProvider>();`
`120`		`- _ = services.AddScoped<IAskAiGateway<Stream>, LlmGatewayAskAiGateway>();`
	`105`	`+ logger?.LogInformation("Configuring AskAi use case for environment {AppEnvironment}", appEnv);`
	`106`	`+ _ = services.AddSingleton<GcpIdTokenProvider>();`
	`107`	`+ _ = services.AddSingleton<IAskAiGateway<Stream>, LlmGatewayAskAiGateway>();`
	`108`	`+ _ = services.AddScoped<LlmGatewayOptions>();`
`121`	`109`	`_ = services.AddScoped<AskAiUsecase>();`
`122`	`110`	`}`
`123`	`111`	`}`