diff --git a/app/MindWork AI Studio/Models/Alibaba/ModelStudioQwenFamily.cs b/app/MindWork AI Studio/Models/Alibaba/ModelStudioQwenFamily.cs index 777d79ee..45ec202c 100644 --- a/app/MindWork AI Studio/Models/Alibaba/ModelStudioQwenFamily.cs +++ b/app/MindWork AI Studio/Models/Alibaba/ModelStudioQwenFamily.cs @@ -8,11 +8,12 @@ namespace AIStudio.Models.Alibaba; /// The Qwen models Alibaba Cloud Model Studio serves. /// /// -/// Everything in this folder is bound to Alibaba Cloud, and that is the point of it. Model Studio -/// sells commercial models -- qwen-max, qwen3.7-max, qwq-plus -- which carry the family names of -/// the open weights without being them, and it answers differently for several names the open -/// weights share with it. The old rules kept the two apart by having two functions; here they are -/// kept apart by saying which provider a rule speaks for. +/// Everything called Model Studio here is bound to Alibaba Cloud, and that is the point of it. +/// Model Studio sells commercial models -- qwen-max, qwen3.7-max, qwq-plus -- which carry the +/// family names of the open weights without being them, and it answers differently for several +/// names the open weights share with it. The old rules kept the two apart by having two functions; +/// here they are kept apart by saying which provider a rule speaks for. The unbound families next +/// to these are the open weights, which answer everywhere else. /// /// The first rule is the catalog's own fallback, and it is written as a plain substring on purpose: /// a substring is the weakest thing a rule can be, so every other rule here beats it without anyone diff --git a/app/MindWork AI Studio/Models/Alibaba/QwenFamily.cs b/app/MindWork AI Studio/Models/Alibaba/QwenFamily.cs new file mode 100644 index 00000000..eea89807 --- /dev/null +++ b/app/MindWork AI Studio/Models/Alibaba/QwenFamily.cs @@ -0,0 +1,77 @@ +using static AIStudio.Provider.Capability; + +namespace AIStudio.Models.Alibaba; + +/// +/// Qwen as everybody except Alibaba Cloud serves it: the open weights. +/// +/// +/// The counterpart to the Model Studio families next door, and the reason those are bound to their +/// provider. Alibaba sells commercial models under the same family names, and for several of them +/// it promises something else than the published checkpoint does. Nothing here is bound: these +/// rules answer wherever the weights are run, which is every gateway and every engine somebody +/// starts on their own machine. +/// +/// The whole line calls functions, from Qwen 2.5 on, and the Coder checkpoints are built for +/// exactly that. Thinking is not promised by the fallback: the older generations cannot do it, and +/// which of the newer ones think by default differs per checkpoint, so those say it one by one. +/// +public sealed class QwenFamily : ModelFamily +{ + /// + public override ModelVendor Vendor => ModelVendor.ALIBABA; + + /// + public override ModelSource Source => new("https://huggingface.co/Qwen", new DateOnly(2026, 9, 11), "Ported unchanged from the Qwen block of ProviderExtensions.OpenSource.cs, which is the one answering everywhere but Alibaba Cloud."); + + /// + protected override void Declare(ModelFamilyBuilder builder) + { + // + // A substring, because the version grows straight out of the family name: there is no name + // part "qwen" in "qwen2.5-72b-instruct". It is also the weakest thing a rule can be, which + // is what lets every rule below beat it without anybody arranging an order. + // + builder.Rule("qwen").AsSubstring() + .Capabilities(TEXT_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API); + + // The VL checkpoints are the ones built to look at pictures: + builder.Rule("qwen").AsSubstring().AlsoContains("vl").Inherits() + .Capabilities(MULTIPLE_IMAGE_INPUT); + + // Qwen 3.5 sees, and thinks when the request asks it to: + builder.Rule("qwen3.5").AsPrefix() + .Capabilities(TEXT_INPUT | MULTIPLE_IMAGE_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API) + .Reasoning(ReasoningSupport.OPTIONAL); + + builder.Rule("qwen3.6").AsPrefix().Inherits() + .Reasoning(ReasoningSupport.ON_BY_DEFAULT); + + // + // The 3.8 tier without a size is the 27B checkpoint: that is what a rolling tag such as + // "qwen3.8:latest" resolves to, so it is what the tier may promise. + // + builder.Rule("qwen3.8").AsPrefix().InheritsFrom("qwen3.6"); + + // Flash-Next is the published checkpoint and Flash the production model; both watch videos: + builder.Rule("qwen3.8-flash").AsPrefix().InheritsFrom("qwen3.8") + .Capabilities(VIDEO_INPUT); + + // + // Blablador writes the 27B checkpoint in two further ways, and no normalization turns + // either into the canonical name: it separates the family from the version ("Qwen 3.8-27B + // with DFlash on haicluster"), and its short alias drops the dot ("alias-qwen38-27b"). + // + builder.Rule("qwen-3.8-27b").AsSegment().InheritsFrom("qwen3.8"); + + builder.Rule("qwen38-27b").AsSegment().InheritsFrom("qwen3.8"); + + // The big 3.8 checkpoint reads nothing but text, and it thinks whatever it is asked: + builder.Rule("qwen3.8-2.4t-a95b").AsPrefix() + .Capabilities(TEXT_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API) + .Reasoning(ReasoningSupport.ALWAYS); + } +} \ No newline at end of file diff --git a/app/MindWork AI Studio/Models/Alibaba/QwqFamily.cs b/app/MindWork AI Studio/Models/Alibaba/QwqFamily.cs new file mode 100644 index 00000000..c23a4199 --- /dev/null +++ b/app/MindWork AI Studio/Models/Alibaba/QwqFamily.cs @@ -0,0 +1,31 @@ +using static AIStudio.Provider.Capability; + +namespace AIStudio.Models.Alibaba; + +/// +/// QwQ as everybody except Alibaba Cloud serves it: the open weights built on Qwen 2.5. +/// +/// +/// The other half of the contradiction the provider-bound rules exist for. What Model Studio sells +/// as "qwq-plus" is a commercial model; QwQ-32B, which the gateways and the local engines serve, is +/// the published checkpoint. The two share a family name and nothing else. +/// +/// Both answer the same here, and for the same reason: neither the model card nor Alibaba's list of +/// models which call functions mentions tools at all. Anybody who knows better says so in the +/// expert settings. +/// +public sealed class QwqFamily : ModelFamily +{ + /// + public override ModelVendor Vendor => ModelVendor.ALIBABA; + + /// + public override ModelSource Source => new("https://huggingface.co/Qwen/QwQ-32B", new DateOnly(2026, 9, 11), "Ported unchanged from the QwQ check of ProviderExtensions.OpenSource.cs: text in, text out, thinking which cannot be switched off, and no tools."); + + /// + protected override void Declare(ModelFamilyBuilder builder) => + builder.Rule("qwq").AsSegment() + .Capabilities(TEXT_INPUT | TEXT_OUTPUT) + .Apis(CHAT_COMPLETION_API) + .Reasoning(ReasoningSupport.ALWAYS); +} \ No newline at end of file diff --git a/app/MindWork AI Studio/Models/Meta/LlamaFamily.cs b/app/MindWork AI Studio/Models/Meta/LlamaFamily.cs new file mode 100644 index 00000000..9db19be3 --- /dev/null +++ b/app/MindWork AI Studio/Models/Meta/LlamaFamily.cs @@ -0,0 +1,62 @@ +using static AIStudio.Provider.Capability; + +namespace AIStudio.Models.Meta; + +/// +/// Llama, from the text-only generations to the natively multimodal 4 line. +/// +/// +/// Every rule here is written as a substring, which no other family needs and this one cannot do +/// without. The same checkpoint arrives as "llama3.1", as "meta-llama-3.1", and as "llama-v3p1", +/// because Fireworks writes a version with a "p" where the dot belongs. There is no name part all +/// three share to anchor a rule to, so the three spellings are stated as three rules. +/// +/// What decides is the generation: 3.1 was the first Llama trained to call functions, which is why +/// the rules carrying the dot are the ones stating it. "llama3" without a dot is Llama 3.0 and does +/// not get it -- the dot in the pattern is what keeps the two apart. +/// +public sealed class LlamaFamily : ModelFamily +{ + /// + public override ModelVendor Vendor => ModelVendor.META; + + /// + public override ModelSource Source => new("https://www.llama.com/docs/model-cards-and-prompt-formats/", new DateOnly(2026, 9, 11), "Ported unchanged from the Llama block of ProviderExtensions.OpenSource.cs."); + + /// + protected override void Declare(ModelFamilyBuilder builder) + { + // Whatever else a Llama is, it reads and writes text: + builder.Rule("llama").AsSubstring() + .Capabilities(TEXT_INPUT | TEXT_OUTPUT) + .Apis(CHAT_COMPLETION_API); + + // + // The 3.2 vision checkpoints look at pictures and were never trained for tools. The word + // sits wherever the provider puts it -- "llama3.2-vision:11b" on Ollama, but + // "Llama-3.2-11B-Vision-Instruct" on the hub -- so there is nothing to anchor to here + // either, and the generations below have to step aside for it by name. + // + builder.Rule("llama").AsSubstring().AlsoContains("vision") + .Capabilities(TEXT_INPUT | MULTIPLE_IMAGE_INPUT | TEXT_OUTPUT) + .Apis(CHAT_COMPLETION_API); + + // From 3.1 on, Llama calls functions. Three spellings, one statement: + builder.Rule("llama3.").AsSubstring().NotContains("vision") + .Capabilities(TEXT_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API); + + builder.Rule("llama-3.").AsSubstring().NotContains("vision").Inherits(); + + builder.Rule("llama-v3p").AsSubstring().NotContains("vision").Inherits(); + + // The 4 line was trained on text and images together, so every one of them sees: + builder.Rule("llama4").AsSubstring() + .Capabilities(TEXT_INPUT | MULTIPLE_IMAGE_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API); + + builder.Rule("llama-4").AsSubstring().Inherits(); + + builder.Rule("llama-v4").AsSubstring().Inherits(); + } +} \ No newline at end of file diff --git a/app/MindWork AI Studio/Models/Meta/MuseFamily.cs b/app/MindWork AI Studio/Models/Meta/MuseFamily.cs new file mode 100644 index 00000000..a25c47c4 --- /dev/null +++ b/app/MindWork AI Studio/Models/Meta/MuseFamily.cs @@ -0,0 +1,30 @@ +using static AIStudio.Provider.Capability; + +namespace AIStudio.Models.Meta; + +/// +/// Muse, the Meta models whose names do not say Llama. +/// +/// +/// That is the whole reason this is a family of its own: nothing about "muse-glimmer-30b" tells the +/// Llama rules that Meta built it, and a rule for one name is cheaper than teaching them. +/// +/// Glimmer always thinks. Its chat template opens the thinking channel whatever the request says, +/// and only the strength of the thinking can be turned down, so there is no mode in which it +/// answers straight away. +/// +public sealed class MuseFamily : ModelFamily +{ + /// + public override ModelVendor Vendor => ModelVendor.META; + + /// + public override ModelSource Source => new("https://huggingface.co/meta-llama", new DateOnly(2026, 9, 11), "Ported unchanged from the Muse block of ProviderExtensions.OpenSource.cs."); + + /// + protected override void Declare(ModelFamilyBuilder builder) => + builder.Rule("muse-glimmer").AsSegment() + .Capabilities(TEXT_INPUT | MULTIPLE_IMAGE_INPUT | TEXT_OUTPUT | FUNCTION_CALLING) + .Apis(CHAT_COMPLETION_API) + .Reasoning(ReasoningSupport.ALWAYS); +} \ No newline at end of file diff --git a/app/MindWork AI Studio/Models/OpenWeights/BaseCheckpointFamily.cs b/app/MindWork AI Studio/Models/OpenWeights/BaseCheckpointFamily.cs new file mode 100644 index 00000000..a3a174fc --- /dev/null +++ b/app/MindWork AI Studio/Models/OpenWeights/BaseCheckpointFamily.cs @@ -0,0 +1,42 @@ +using AIStudio.Provider; + +using static AIStudio.Provider.Capability; + +namespace AIStudio.Models.OpenWeights; + +/// +/// Base checkpoints, whatever family they come from. +/// +/// +/// A base checkpoint is the model before anybody taught it to answer: it continues a text, it knows +/// no chat template, and there is nothing in it that a tool definition could reach. Which family it +/// belongs to changes none of that, which is why this states a modifier rather than a rule of its +/// own -- the family says what the model is, and this takes away what the instruction tuning would +/// have added. +/// +/// Reading pictures goes with it. The vision tower may well be there, but without a template there +/// is no way to hand an image to it, so promising the chat that it can send one would be a promise +/// nobody can keep. +/// +/// The name part has to be exactly "base", so that a model whose name merely carries the word, as +/// in "based", is left alone. +/// +public sealed class BaseCheckpointFamily : ModelFamily +{ + private const Capability WHAT_THE_INSTRUCTION_TUNING_WOULD_HAVE_ADDED = + SINGLE_IMAGE_INPUT | MULTIPLE_IMAGE_INPUT | AUDIO_INPUT | SPEECH_INPUT | VIDEO_INPUT | + AUDIO_OUTPUT | IMAGE_OUTPUT | SPEECH_OUTPUT | VIDEO_OUTPUT | + FUNCTION_CALLING | WEB_SEARCH; + + /// + public override ModelVendor Vendor => ModelVendor.UNKNOWN; + + /// + public override ModelSource Source => new("https://huggingface.co/docs/transformers/en/chat_templating", new DateOnly(2026, 9, 11), "Ported unchanged from the base checkpoint check of ProviderExtensions.OpenSource.cs, which answers before any family is asked."); + + /// + protected override void Declare(ModelFamilyBuilder builder) => + builder.Modifier("base").AsSegment() + .Removes(WHAT_THE_INSTRUCTION_TUNING_WOULD_HAVE_ADDED) + .Reasoning(ReasoningSupport.NONE); +} \ No newline at end of file diff --git a/app/Tests/Models/PortingDifferenceTests.cs b/app/Tests/Models/PortingDifferenceTests.cs index cf3b5fe4..57c0b1a4 100644 --- a/app/Tests/Models/PortingDifferenceTests.cs +++ b/app/Tests/Models/PortingDifferenceTests.cs @@ -1,3 +1,4 @@ +using AIStudio.Models; using AIStudio.Models.Registry; using AIStudio.Provider; using AIStudio.Tests.Models.Corpus; @@ -13,8 +14,9 @@ namespace AIStudio.Tests.Models; /// old answer wrong, and there they have to answer what was written down instead. Anything else is /// either a porting mistake or a decision somebody has to make on purpose and record. /// -/// The list below is what grows. A provider not on it is simply not compared yet: its models reach -/// rules which have not been written, and holding them to anything would only say that. +/// The two lists below are what grow. A provider not on either is simply not compared yet: its +/// models reach rules which have not been written, and holding them to anything would only say +/// that. /// [TestFixture] public sealed class PortingDifferenceTests @@ -39,15 +41,51 @@ public sealed class PortingDifferenceTests LLMProviders.X, ]; + /// + /// The vendors whose models the rebuilt rules already answer for, whoever serves them. + /// + /// + /// Open weights are the reason this list exists next to the one above. They arrive through the + /// gateways and the local engines, and none of those can be called ported until every vendor + /// they carry is. The vendor is the unit the porting actually proceeds in: as soon as the Llama + /// rules exist, every Llama of the corpus is compared, whichever gateway it came from. + /// + /// It is also what finally holds the cloud vendors to their models on somebody else's gateway, + /// which the provider list alone never reached: a Claude at GWDG and a DeepSeek distill at + /// OpenRouter are compared here, not at Anthropic and not at DeepSeek. + /// + /// Only vendors, never UNKNOWN: that is what a model nobody wrote a rule for answers with, and + /// putting it here would compare everything against everything. + /// + /// Mistral is the one ported vendor still missing. Its cloud writes a release date into every + /// name and its rules are built on that, while the open weights are called + /// "mistral-small-3.1-24b-instruct" and carry none -- so those names are still to be ported. + /// + private static readonly IReadOnlyList VENDORS_ALREADY_PORTED = + [ + ModelVendor.OPEN_AI, + ModelVendor.ANTHROPIC, + ModelVendor.GOOGLE, + ModelVendor.ALIBABA, + ModelVendor.DEEP_SEEK, + ModelVendor.PERPLEXITY, + ModelVendor.XAI, + ModelVendor.META, + ]; + + /// + /// Who built the models of each family, by the name its rules name as their origin. + /// + private static readonly IReadOnlyDictionary VENDOR_OF_FAMILY = ModelRegistry.Shared.Families.ToDictionary(family => family.Name, family => family.Vendor, StringComparer.Ordinal); + [Test] public void EveryPortedModelGetsExactlyTheAnswerItGetsToday() { - var compared = PortedEntries().Where(entry => !IsKnownToBeWrong(entry)).ToList(); + var compared = ComparableEntries().Where(entry => !IsKnownToBeWrong(entry)).ToList(); Assert.Multiple(() => { Assert.That(compared, Is.Not.Empty, "Nothing was compared at all, which would make this test green for the wrong reason."); - foreach (var entry in compared) { var today = CapabilitySnapshot.Describe(CapabilitySnapshot.AskTheCurrentRules(entry)); @@ -61,7 +99,7 @@ public sealed class PortingDifferenceTests [Test] public void EveryPortedModelTheAuditFoundWrongIsNowAnsweredTheWayItShouldBe() { - var ported = ExpectedChanges.ENTRIES.Where(change => PROVIDERS_ALREADY_PORTED.Contains(change.Provider)).ToList(); + var ported = ExpectedChanges.ENTRIES.Where(change => IsCompared(change.Provider, change.ModelId)).ToList(); Assert.Multiple(() => { @@ -85,17 +123,35 @@ public sealed class PortingDifferenceTests // profile, and where the old answer was empty too, the comparison is happy -- while the // model has in fact disappeared from the rules. This is the test which notices. // - var named = PortedEntries().Where(entry => !string.IsNullOrWhiteSpace(entry.ModelId)).ToList(); + // Only the ported providers, and on purpose: a model is on the vendor list exactly because + // a rule answered for it, so asking those the same question would answer itself. + // + var named = EntriesOfPortedProviders().Where(entry => !string.IsNullOrWhiteSpace(entry.ModelId)).ToList(); Assert.Multiple(() => { Assert.That(named, Is.Not.Empty, "Nothing was asked about at all, which would make this test green for the wrong reason."); foreach (var entry in named) + Assert.That(ModelRegistry.Shared.Explain(entry.Provider, entry.ModelId).IsKnown, Is.True, $"No rule answers for {entry.Provider} \"{entry.ModelId}\"."); + }); + } + + [Test] + public void NoModelOfTheCorpusIsClaimedByTwoRulesWithTheSameRight() + { + // + // The whole corpus, ported or not: a tie needs two rules that both exist, so every name is + // worth asking about as soon as anything answers for it. This is where a family which + // repeats what another one already said shows up -- reading the rules alone cannot find + // that, because the two patterns are written differently and only meet on a real name. + // + Assert.Multiple(() => + { + foreach (var entry in ModelCorpus.ENTRIES) { var resolution = ModelRegistry.Shared.Explain(entry.Provider, entry.ModelId); - Assert.That(resolution.IsKnown, Is.True, $"No rule answers for {entry.Provider} \"{entry.ModelId}\"."); Assert.That(resolution.IsAmbiguous, Is.False, $"{entry.Provider} \"{entry.ModelId}\" is claimed by {resolution.Selector} and, just as strongly, by {string.Join(", ", resolution.TiedSelectors)}."); } }); @@ -105,7 +161,33 @@ public sealed class PortingDifferenceTests /// Every corpus entry of a provider which has been ported, known-wrong ones included. /// /// The entries. - private static IEnumerable PortedEntries() => ModelCorpus.ENTRIES.Where(entry => PROVIDERS_ALREADY_PORTED.Contains(entry.Provider)); + private static IEnumerable EntriesOfPortedProviders() => ModelCorpus.ENTRIES.Where(entry => PROVIDERS_ALREADY_PORTED.Contains(entry.Provider)); + + /// + /// Every corpus entry the rebuilt rules are already meant to answer for. + /// + /// The entries. + private static IEnumerable ComparableEntries() => ModelCorpus.ENTRIES.Where(entry => IsCompared(entry.Provider, entry.ModelId)); + + /// + /// Whether the rebuilt rules are held to what the old ones answer for this model. + /// + /// Who serves the model. + /// The model ID as that provider reports it. + /// True, when the two answers have to agree. + private static bool IsCompared(LLMProviders provider, string modelId) => PROVIDERS_ALREADY_PORTED.Contains(provider) || VENDORS_ALREADY_PORTED.Contains(VendorAnswering(provider, modelId)); + + /// + /// Whose rules answered for a model, as far as any did. + /// + /// Who serves the model. + /// The model ID as that provider reports it. + /// The vendor of the family whose rule chose, or UNKNOWN when none did. + private static ModelVendor VendorAnswering(LLMProviders provider, string modelId) + { + var selector = ModelRegistry.Shared.Explain(provider, modelId).Selector; + return selector is null ? ModelVendor.UNKNOWN : VENDOR_OF_FAMILY.GetValueOrDefault(selector.Origin, ModelVendor.UNKNOWN); + } /// /// Whether the audit found the current answer for this entry wrong.