Fixed GPT-6 Sol and Luna, and the system prompt role of newer OpenAI models (#1010)

app/Tests/Models/OpenAI/Gpt6FamilyTests.cs

@@ -0,0 +1,50 @@
+using AIStudio.Models;
+using AIStudio.Provider;
+using AIStudio.Settings;
+// ReSharper disable InconsistentNaming
+
+namespace AIStudio.Tests.Models.OpenAI;
+
+/// <summary>
+/// Checks what AI Studio knows about the GPT-6 models when it reaches them at OpenAI itself.
+/// </summary>
+/// <remarks>
+/// OpenAI serves three GPT-6 models, and for a while the rules knew one of them. The other two fell
+/// through to the global assumption, which puts a model on the chat completion API with neither
+/// images nor web search nor reasoning. Nothing looked wrong from the outside until a request
+/// carrying a Responses API parameter was turned down.
+///
+/// The questions go through the same chain the OpenAI provider asks, assumption included, because
+/// that is where a model which no rule knows ends up looking like one somebody described.
+/// </remarks>
+[TestFixture]
+public sealed class Gpt6FamilyTests
+{
+    [TestCase("gpt-6-astra", TestName = "Astra is reached through the Responses API")]
+    [TestCase("gpt-6-sol", TestName = "Sol is reached through the Responses API")]
+    [TestCase("gpt-6-luna", TestName = "Luna is reached through the Responses API")]
+    public void EveryGpt6ModelIsAnsweredLikeTheModelPageDescribesIt(string modelId)
+    {
+        var profile = LLMProviders.OPEN_AI.GetModelProfile(new Model(modelId, null));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(profile.Has(Capability.RESPONSES_API), Is.True);
+            Assert.That(profile.Has(Capability.MULTIPLE_IMAGE_INPUT), Is.True);
+            Assert.That(profile.Has(Capability.FUNCTION_CALLING), Is.True);
+            Assert.That(profile.Has(Capability.WEB_SEARCH), Is.True);
+            Assert.That(profile.Context.IsKnown, Is.True);
+            Assert.That(profile.Context.DefaultTokens, Is.EqualTo(1_050_000));
+        });
+    }
+
+    [TestCase("gpt-6-astra", ReasoningSupport.ALWAYS, TestName = "Astra reasons on every request")]
+    [TestCase("gpt-6-sol", ReasoningSupport.ON_BY_DEFAULT, TestName = "Sol reasons unless the effort is set to none")]
+    [TestCase("gpt-6-luna", ReasoningSupport.ON_BY_DEFAULT, TestName = "Luna reasons unless the effort is set to none")]
+    public void EveryGpt6ModelReasonsTheWayItsModelPageSays(string modelId, ReasoningSupport reasoning)
+    {
+        var profile = LLMProviders.OPEN_AI.GetModelProfile(new Model(modelId, null));
+
+        Assert.That(profile.Reasoning, Is.EqualTo(reasoning));
+    }
+}

app/Tests/Models/OpenAI/NewOpenAIModelTests.cs

@@ -0,0 +1,69 @@
+using AIStudio.Models;
+using AIStudio.Provider;
+using AIStudio.Settings;
+// ReSharper disable InconsistentNaming
+
+namespace AIStudio.Tests.Models.OpenAI;
+
+/// <summary>
+/// Checks what AI Studio assumes about an OpenAI model released after its rules were written.
+/// </summary>
+/// <remarks>
+/// OpenAI releases faster than anybody writes rules, and a new generation is always reached by
+/// somebody first. What that person must get is what every current OpenAI model does: it calls
+/// tools, it looks at images, it reasons, and it answers through the Responses API. The global
+/// assumption says none of that except the tools, and it sends the model to the chat completion
+/// API, where a parameter meant for the Responses API is turned down.
+///
+/// The names below are invented on purpose. A real name belongs in the corpus; these stand for the
+/// one nobody has seen yet, which is exactly the name no corpus can hold.
+/// </remarks>
+[TestFixture]
+public sealed class NewOpenAIModelTests
+{
+    [TestCase("gpt-99", TestName = "A generation nobody wrote a rule for")]
+    [TestCase("gpt-99-mini", TestName = "A variant of a generation nobody wrote a rule for")]
+    public void ANewOpenAIModelIsAnsweredLikeTheCurrentOnes(string modelId)
+    {
+        var profile = LLMProviders.OPEN_AI.GetModelProfile(new Model(modelId, null));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(profile.Has(Capability.RESPONSES_API), Is.True);
+            Assert.That(profile.Has(Capability.FUNCTION_CALLING), Is.True);
+            Assert.That(profile.Has(Capability.MULTIPLE_IMAGE_INPUT), Is.True);
+            Assert.That(profile.Reasoning, Is.Not.EqualTo(ReasoningSupport.NONE));
+        });
+    }
+
+    [Test]
+    public void TheOpenWeightsKeepTheirOwnRuleEvenAtOpenAI()
+    {
+        //
+        // How a pattern matches is weighed before how long it is. Written as a prefix, the
+        // baseline would outrank the name part "gpt-oss" and hand the open weights reasoning and
+        // the Responses API. OpenAI does not serve them today; the test is about which rule wins.
+        //
+        var profile = LLMProviders.OPEN_AI.GetModelProfile(new Model("gpt-oss-120b", null));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(profile.Has(Capability.RESPONSES_API), Is.False);
+            Assert.That(profile.Reasoning, Is.EqualTo(ReasoningSupport.NONE));
+            Assert.That(profile.Context.DefaultTokens, Is.EqualTo(131_072));
+        });
+    }
+
+    [Test]
+    public void AModelNamedGptElsewhereIsNotTakenForAnOpenAIModel()
+    {
+        var profile = LLMProviders.SELF_HOSTED.GetModelProfile(new Model("gpt-j-6b", null));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(profile.Has(Capability.RESPONSES_API), Is.False);
+            Assert.That(profile.Has(Capability.MULTIPLE_IMAGE_INPUT), Is.False);
+            Assert.That(profile.Reasoning, Is.EqualTo(ReasoningSupport.NONE));
+        });
+    }
+}