Analyze this production incident and provide severity, cause, and recommended actions.

The issue appears related to the database cluster. The severity is high since users cannot access checkout. Engineers should investigate slow queries and scale replicas.

public sealed class LlmAppConfig
{
  public string Provider { get; init; } = "lmstudio";
  public string BaseUrl { get; init; } = "http://localhost:1234/v1";
  public string ApiKey { get; init; } = "not-needed";
  public string ModelId { get; init; } = "deepseek/deepseek-r1-0528-qwen3-8b";
  public float Temperature { get; init; } = 0.0f;
  public bool UseTypedResponseFormat { get; init; } = true;

  public void Validate()
  {
      if (string.IsNullOrWhiteSpace(BaseUrl))
          throw new InvalidOperationException("Llm:BaseUrl is required.");
      if (!Uri.TryCreate(BaseUrl, UriKind.Absolute, out _))
          throw new InvalidOperationException("Llm:BaseUrl must be an absolute URI.");
      if (string.IsNullOrWhiteSpace(ModelId))
          throw new InvalidOperationException("Llm:ModelId is required.");
      if (string.IsNullOrWhiteSpace(ApiKey))
          throw new InvalidOperationException("Llm:ApiKey is required.");
  }
}

public sealed class IncidentContextEnvelope
{
  public IncidentContext Incident { get; init; } = new();
}

public sealed class IncidentContext
{
  public string IncidentId { get; init; } = string.Empty;
  public string Service { get; init; } = string.Empty;
  public string Region { get; init; } = string.Empty;
  public int ErrorRatePercent { get; init; }
  public int P95LatencyMs { get; init; }
  public int ActiveCheckoutSessions { get; init; }
  public List<string> Symptoms { get; init; } = [];
  public List<string> RecentChanges { get; init; } = [];
  public string DetectedAtUtc { get; init; } = string.Empty;
}

public sealed class IncidentAnalysis
{
  public string Severity { get; set; } = string.Empty;
  public string PrimaryCause { get; set; } = string.Empty;
  public List<string> RecommendedActions { get; set; } = [];
  public List<string> MissingData { get; set; } = [];
}

{
"type": "object",
"properties": {
  "Severity": { "type": "string", "enum": ["P1", "P2", "P3", "P4"] },
  "PrimaryCause": { "type": "string" },
  "RecommendedActions": { "type": "array", "items": { "type": "string" } },
  "MissingData": { "type": "array", "items": { "type": "string" } }
},
"required": ["Severity", "PrimaryCause", "RecommendedActions", "MissingData"]
}

var prompt = $"""
You are a production incident analysis system.

Rules:
1. Never invent metrics not provided.
2. Use severity only: P1,P2,P3,P4.
3. Provide at least 3 recommended actions.
4. Put unknowns in MissingData.
5. Return JSON only and follow the schema.

Output JSON schema:
{responseSchema}

Incident context:
{incidentContextJson}
""";

var typedSettings = new OpenAIPromptExecutionSettings
{
  Temperature = config.Temperature
};

if (config.UseTypedResponseFormat)
  typedSettings.ResponseFormat = typeof(IncidentAnalysis);

static async Task<string> InvokeWithTypedFallbackAsync(
  Kernel kernel,
  string prompt,
  OpenAIPromptExecutionSettings typedSettings,
  LlmAppConfig config)
{
  try
  {
      var result = await kernel.InvokePromptAsync(prompt, new KernelArguments(typedSettings));
      return result.ToString();
  }
  catch when (config.UseTypedResponseFormat)
  {
      var fallbackSettings = new OpenAIPromptExecutionSettings { Temperature = config.Temperature };
      var fallback = await kernel.InvokePromptAsync(prompt, new KernelArguments(fallbackSettings));
      return fallback.ToString();
  }
}

static string NormalizeJson(string payload)
{
  var trimmed = payload.Trim();

  if (trimmed.StartsWith("```", StringComparison.Ordinal))
  {
      var firstNewLine = trimmed.IndexOf('\n');
      var lastFence = trimmed.LastIndexOf("```", StringComparison.Ordinal);
      if (firstNewLine >= 0 && lastFence > firstNewLine)
          trimmed = trimmed[(firstNewLine + 1)..lastFence].Trim();
  }

  var firstBrace = trimmed.IndexOf('{');
  var lastBrace = trimmed.LastIndexOf('}');
  if (firstBrace >= 0 && lastBrace > firstBrace)
      return trimmed[firstBrace..(lastBrace + 1)];

  return trimmed;
}

public static List<string> Validate(IncidentAnalysis analysis)
{
  var errors = new List<string>();
  if (!AllowedSeverity.Contains(analysis.Severity))
      errors.Add("Severity must be one of P1/P2/P3/P4.");
  if (string.IsNullOrWhiteSpace(analysis.PrimaryCause))
      errors.Add("PrimaryCause is required.");
  if (analysis.RecommendedActions.Count < 3)
      errors.Add("RecommendedActions must include at least 3 actions.");
  return errors;
}

public sealed class IncidentExecutionDecision
{
  public string TicketPriority { get; init; } = string.Empty;
  public string TicketQueue { get; init; } = string.Empty;
  public string EscalationTarget { get; init; } = string.Empty;
  public int MitigationSlaMinutes { get; init; }
  public string ExecutionMode { get; init; } = string.Empty;
  public bool FreezeDeployments { get; init; }
  public List<string> DeterministicActions { get; init; } = [];
}