@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/domains/providers/extension.ts

@@ -156,6 +156,7 @@ function sameProbeIdentity(previous: TargetDescriptor, next: TargetDescriptor):
 
 export interface ProbeMerge {
 	discoveredModels: string[];
+	discoveredModelLabels: Readonly<Record<string, string>>;
 	discoveredModelsSource: "probe" | "cache" | "runtime" | "none";
 	discoveredModelStates: NonNullable<TargetStatus["discoveredModelStates"]> | null;
 	probeCapabilities: NonNullable<TargetStatus["probeCapabilities"]> | null;
@@ -179,6 +180,7 @@ function mergeProbeResult(
 	probe: ProbeResult | null,
 	previous: TargetStatus | undefined,
 	cachedModels: ReadonlyArray<string> = [],
+	cachedModelLabels: Readonly<Record<string, string>> = {},
 ): ProbeMerge {
 	const probeSucceeded = probe?.ok ?? false;
 	const preservePrevious = !probeSucceeded && previous !== undefined && sameProbeIdentity(previous.target, target);
@@ -201,8 +203,14 @@ function mergeProbeResult(
 			[],
 	);
 	const discoveredModelStates = probe?.modelStates ?? (preservePrevious ? previous.discoveredModelStates : null) ?? null;
+	const discoveredModelLabels =
+		probe?.modelLabels ??
+		(preservePrevious ? previous.discoveredModelLabels : undefined) ??
+		(cachedModels.length > 0 ? cachedModelLabels : undefined) ??
+		{};
 	const merge: ProbeMerge = {
 		discoveredModels,
+		discoveredModelLabels,
 		discoveredModelsSource: discoveredModelsSource(probe, preservePrevious, previous, cachedModels, desc),
 		discoveredModelStates,
 		probeCapabilities,
@@ -225,14 +233,16 @@ function mergeProbeResult(
  * there is no live evidence either way.
  */
 function unservedDefaultModelReason(
-	desc: Pick<RuntimeDescriptor, "id">,
+	desc: Pick<RuntimeDescriptor, "id" | "externalAgentLoop">,
 	target: Pick<TargetDescriptor, "defaultModel">,
 	merge: Pick<ProbeMerge, "discoveredModels" | "discoveredModelsSource" | "discoveredModelStates">,
 ): string | null {
 	const model = target.defaultModel;
 	if (!model) return null;
 	if (merge.discoveredModelsSource !== "probe" || merge.discoveredModels.length === 0) return null;
-	if (listKnownModelsForRuntime(desc.id).length > 0) return null;
+	if (listKnownModelsForRuntime(desc.id).length > 0 && desc.externalAgentLoop?.modelCatalog !== "live-authoritative") {
+		return null;
+	}
 	if (merge.discoveredModels.includes(model)) return null;
 	// LM Studio lists a loaded model under its instance id and keeps the model
 	// key in the state map; the request path resolves either.
@@ -258,14 +268,22 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		return readSettings();
 	}
 
-	async function buildProbeContextForTarget(target: TargetDescriptor, desc: RuntimeDescriptor): Promise<ProbeContext> {
+	async function buildProbeContextForTarget(
+		target: TargetDescriptor,
+		desc: RuntimeDescriptor,
+		signal?: AbortSignal,
+	): Promise<ProbeContext> {
 		const probeCtx: ProbeContext = {
 			credentialsPresent: credentialsPresent(),
 			httpTimeoutMs: DEFAULT_PROBE_TIMEOUT_MS,
+			...(signal ? { signal } : {}),
 		};
 		if (!targetRequiresAuth(target, desc)) return probeCtx;
 		try {
-			const resolution = await authStore.resolveForTarget(resolveAuthTarget(target, desc), { includeFallback: false });
+			const resolution = await authStore.resolveForTarget(resolveAuthTarget(target, desc), {
+				includeFallback: false,
+				...(signal ? { signal } : {}),
+			});
 			if (resolution.apiKey) probeCtx.authToken = resolution.apiKey;
 		} catch {
 			// Authenticated probes should still return a runtime-specific missing-auth error.
@@ -325,8 +343,9 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			return out;
 		}
 		const availability = availabilityFor(desc, target, authStatusFor);
-		const cachedModels = readTargetModelSnapshot(target)?.models ?? [];
-		const merge = mergeProbeResult(desc, target, probe, previous, cachedModels);
+		const cachedSnapshot = readTargetModelSnapshot(target);
+		const cachedModels = cachedSnapshot?.models ?? [];
+		const merge = mergeProbeResult(desc, target, probe, previous, cachedModels, cachedSnapshot?.modelLabels ?? {});
 		const { capabilities, contextWindowProvenance } = capabilitiesFor(desc, target, merge, kb);
 		const healthy = probe !== null ? probe.ok : null;
 		const unservedDefault = probe?.ok ? unservedDefaultModelReason(desc, target, merge) : null;
@@ -353,6 +372,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			probeModelCapabilities: merge.probeModelCapabilities,
 			probeModelId: merge.probeModelId,
 			discoveredModels: merge.discoveredModels,
+			discoveredModelLabels: merge.discoveredModelLabels,
 			discoveredModelsSource: merge.discoveredModelsSource,
 			discoveredModelStates: merge.discoveredModelStates,
 		};
@@ -364,8 +384,9 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	async function probeTargetInternal(
 		target: TargetDescriptor,
 		live: boolean,
-		options?: { reasoning?: boolean },
+		options?: { reasoning?: boolean; signal?: AbortSignal },
 	): Promise<TargetStatus> {
+		options?.signal?.throwIfAborted();
 		const previous = statuses.get(target.id);
 		const desc = registry.get(target.runtime);
 		if (!desc) {
@@ -379,13 +400,15 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			statuses.set(target.id, status);
 			return status;
 		}
-		const probeCtx = await buildProbeContextForTarget(target, desc);
+		const probeCtx = await buildProbeContextForTarget(target, desc, options?.signal);
+		options?.signal?.throwIfAborted();
 		let probeResult: ProbeResult;
 		try {
 			probeResult = await desc.probe(target, probeCtx);
 		} catch (err) {
 			probeResult = { ok: false, error: err instanceof Error ? err.message : String(err) };
 		}
+		options?.signal?.throwIfAborted();
 		if (probeResult.ok && typeof desc.probeModels === "function" && !probeResult.models) {
 			try {
 				const ids = await desc.probeModels(target, probeCtx);
@@ -394,6 +417,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				// model discovery is best-effort; keep probe as-is.
 			}
 		}
+		options?.signal?.throwIfAborted();
 		if (probeResult.ok && options?.reasoning !== false && typeof desc.probeReasoning === "function") {
 			const settings = readConfig();
 			const orchestratorTarget = settings.chat.target === target.id ? settings.chat.model : null;
@@ -401,6 +425,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			if (candidateModelId) {
 				try {
 					const result = await desc.probeReasoning(target, candidateModelId, probeCtx);
+					options?.signal?.throwIfAborted();
 					reasoningCache.set(reasoningCacheKey(target.id, candidateModelId), result.reasoning);
 					const capabilityModelId = probeResult.capabilityModelId ?? null;
 					if (capabilityModelId === null || capabilityModelId === candidateModelId) {
@@ -422,10 +447,16 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				}
 			}
 		}
+		// A cancelled role preparation must not publish failed/stale target state.
+		options?.signal?.throwIfAborted();
 		const status = buildStatus(target, desc, probeResult, previous);
 		statuses.set(target.id, status);
 		if (probeResult.ok && probeResult.models !== undefined) {
-			recordTargetModelSnapshot(target, probeResult.models);
+			recordTargetModelSnapshot(
+				target,
+				probeResult.models,
+				probeResult.modelLabels ? { modelLabels: probeResult.modelLabels } : {},
+			);
 		}
 		// Durable so the next process resolves this endpoint's real slot count
 		// instead of the conservative default. Fire and forget: the probe's answer

package/src/domains/providers/model-capabilities.ts

@@ -14,6 +14,7 @@ export interface ModelCapabilityPatchTarget {
 	contextWindow?: number;
 	maxTokens?: number;
 	reasoning?: boolean;
+	clioCoder?: Record<string, unknown>;
 }
 
 /**
@@ -30,6 +31,14 @@ export function applyModelCapabilityPatch<T extends ModelCapabilityPatchTarget>(
 	if (typeof caps.contextWindow === "number") model.contextWindow = caps.contextWindow;
 	if (typeof caps.maxTokens === "number") model.maxTokens = caps.maxTokens;
 	if (typeof caps.reasoning === "boolean") model.reasoning = caps.reasoning;
+	// Refresh the probe-only control hint together with the capability snapshot.
+	// Missing metadata after a later probe must not retain an earlier route claim.
+	if (model.clioCoder || caps.thinkingControlRuntime !== undefined) {
+		const metadata = { ...model.clioCoder };
+		delete metadata.thinkingControlRuntime;
+		if (caps.thinkingControlRuntime !== undefined) metadata.thinkingControlRuntime = caps.thinkingControlRuntime;
+		model.clioCoder = metadata;
+	}
 	return model;
 }
 

package/src/domains/providers/model-discovery.ts

@@ -6,6 +6,7 @@ export type ProviderModelSource = "configured" | "live" | "catalog" | "default";
 
 export interface ProviderModelCandidate {
 	id: string;
+	label?: string;
 	source: ProviderModelSource;
 	loadState?: string;
 	loadStateDetail?: string;
@@ -75,10 +76,7 @@ export function modelResidencyForStatus(status: DiscoveryStatus | null | undefin
 }
 
 export function hasLiveModelCatalog(status: TargetStatus): boolean {
-	if (status.discoveredModelsSource === "probe" || status.discoveredModelsSource === "cache") return true;
-	// Unit-test and plugin mocks from before `discoveredModelsSource` still use
-	// `discoveredModels` to mean "this came from discovery".
-	return status.discoveredModelsSource === undefined && status.discoveredModels.length > 0;
+	return status.discoveredModelsSource === "probe" || status.discoveredModelsSource === "cache";
 }
 
 /**
@@ -100,6 +98,7 @@ export function modelCandidatesForStatus(status: TargetStatus): ProviderModelCan
 		const state = status.discoveredModelStates?.[trimmed];
 		out.push({
 			id: trimmed,
+			...(status.discoveredModelLabels?.[trimmed] ? { label: status.discoveredModelLabels[trimmed] } : {}),
 			source,
 			...(state ? { loadState: state.state } : {}),
 			...(state?.detail ? { loadStateDetail: state.detail } : {}),

package/src/domains/providers/model-runtime-capabilities.ts

@@ -131,6 +131,7 @@ interface ClioRuntimeMetadata {
 		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
+		thinkingControlRuntime?: CapabilityFlags["thinkingControlRuntime"];
 		quirks?: LocalModelQuirks;
 	};
 	/** Released in-memory metadata name accepted at plugin/runtime read boundaries. */
@@ -140,6 +141,7 @@ interface ClioRuntimeMetadata {
 		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
+		thinkingControlRuntime?: CapabilityFlags["thinkingControlRuntime"];
 		quirks?: LocalModelQuirks;
 	};
 	compat?: {
@@ -381,9 +383,10 @@ export function effectiveThinkingLevel(
 	const fallback = available[0] ?? "off";
 	if (!configured) return fallback;
 	if (available.includes(configured)) return configured;
-	// Catalog effort maps intentionally stop at xhigh; `max` must clamp to that
-	// supported ceiling instead of falling through to the generic low fallback.
-	if (configured === "max" && available.includes("xhigh")) return "xhigh";
+	// A family with xhigh but no high keeps the released high alias at its
+	// supported ceiling; neither high nor max may fall through to low.
+	if ((configured === "max" || (configured === "high" && !available.includes("high"))) && available.includes("xhigh"))
+		return "xhigh";
 	if ((configured === "high" || configured === "xhigh" || configured === "max") && available.includes("high")) {
 		return "high";
 	}
@@ -553,7 +556,7 @@ function resolveThinkingCapability(
  */
 const REASONING_EFFORT_ONLY_RUNTIMES: ReadonlySet<string> = new Set(["lmstudio"]);
 
-/** `none` is LM Studio's documented off value; on-off models have no finer dial than `low`. */
+/** `none` is the observed LM Studio HTTP off value; on-off models have no finer dial than `low`. */
 function onOffReasoningEffort(thinkingActive: boolean): string {
 	return thinkingActive ? "low" : "none";
 }
@@ -647,7 +650,12 @@ export function resolveModelRuntimeCapabilities(
 		family,
 		capabilities: input.capabilities,
 		thinking,
-		request: resolveRequestCapability(thinking, parser, input.runtimeId, quirks),
+		request: resolveRequestCapability(
+			thinking,
+			parser,
+			input.runtimeId === "litellm" ? (input.capabilities.thinkingControlRuntime ?? input.runtimeId) : input.runtimeId,
+			quirks,
+		),
 		response: {
 			parser,
 			stripTokenizerSentinels: true,
@@ -735,6 +743,7 @@ function thinkingFormatFromModelApi(api: Api): CapabilityFlags["thinkingFormat"]
 
 function capabilitiesFromModel(model: Model<Api> & ClioRuntimeMetadata): CapabilityFlags {
 	const format = model.compat?.thinkingFormat ?? thinkingFormatFromModelApi(model.api);
+	const controlRuntime = (model.clioCoder ?? model.clio)?.thinkingControlRuntime;
 	const caps: CapabilityFlags = {
 		chat: true,
 		tools: true,
@@ -746,6 +755,7 @@ function capabilitiesFromModel(model: Model<Api> & ClioRuntimeMetadata): Capabil
 		fim: false,
 		contextWindow: model.contextWindow,
 		maxTokens: model.maxTokens,
+		...(controlRuntime ? { thinkingControlRuntime: controlRuntime } : {}),
 	};
 	if (
 		format === "qwen-chat-template" ||

package/src/domains/providers/models/local-models/clio-coder-local-coding-targets.yaml

@@ -561,8 +561,12 @@
       guidance: |
         Ornith 1.5's Qwen3.5 chat template exposes thinking as on or off
         through enable_thinking; intermediate levels coerce to on. LM Studio
-        reads the same switch from reasoning_effort (none or low), which Clio
-        sends for on-off models on that runtime.
+        2026-09-03 exposed a split vocabulary on this exact Q4_K_M: native
+        discovery advertised {off,on}, while its OpenAI-compatible request
+        validator rejected literal `on` and accepted only effort-level values.
+        `low` ran only after a warning and fallback to on, so Clio now omits an
+        active override for this default-on model and sends `reasoning_effort:
+        none` only when disabling it.
     serving: "Ornith-1.5-35B-A3B follows the 1.0 card: 262K context, qwen3 reasoning parsing, qwen3_coder tool parsing, sampler temperature=0.6, top_p=0.95, top_k=20."
 
 - family: qwen3.6-27b
@@ -696,7 +700,7 @@
       "128gb-unified-vulkan": "128 GB unified-memory Vulkan class: IQ4_NL uses about 17.3 GB and fits ctx=262144 with parallel=4. Vulkan backends show much slower prefill than ROCm/CUDA on this family; prefer ROCm where available."
     runtimePreference:
       llamaCpp: "Primary verified path. OpenAI-compatible chat completions with --jinja, --reasoning on, --reasoning-effort medium as server defaults; reasoning_content and tool_calls both confirmed to parse correctly. A request can override to off with chat_template_kwargs.enable_thinking:false, or to a different active level with reasoning_effort in {low, medium, xhigh} (never minimal/high/max on the wire; the stock template raises a fatal jinja exception on those and Clio's landed capability resolver already clamps to this set)."
-      lmstudioOpenaiCompat: "Clio sends reasoning_effort over LM Studio's OpenAI-compatible HTTP port and omits chat_template_kwargs because LM Studio does not use that field for this model. With no override, LM Studio defaults this model to thinking off, unlike raw llama.cpp's template default of thinking on/xhigh. reasoning_effort:'none' explicitly disables it."
+      lmstudioOpenaiCompat: "Clio sends reasoning_effort over LM Studio's OpenAI-compatible HTTP port and omits chat_template_kwargs because LM Studio does not use that field for this model. The upstream template defaults to thinking on/xhigh; an LM Studio deployment may configure another default. reasoning_effort:'none' explicitly disables it. Through LiteLLM, this control also requires allowed_openai_params:['reasoning_effort']; Clio selects the LM Studio spelling only when every deployment of that alias explicitly declares model_info.runtime: lm-studio."
       lmstudioNative: "Clio's LM Studio runtime uses the OpenAI-compatible HTTP chat adapter with native REST model discovery and residency management."
     llamaCpp:
       ctxSize: 131072
@@ -718,7 +722,6 @@
       effortByLevel:
         low: low
         medium: medium
-        high: xhigh
         xhigh: xhigh
       guidance: |
         Official Qwen3.8-27B chat template (chat_template.jinja) validates
@@ -726,19 +729,32 @@
         fatal jinja exception (hard 500, not a graceful fallback) on anything
         else, including minimal/high/max. The 27B card gives no /think or
         /no_think soft switch for this model; unlike Qwen3, that idiom has no
-        effect here. Off must go through chat_template_kwargs.enable_thinking:
-        false, never through reasoning_effort. preserve_thinking should stay
+        effect here. The template defaults to xhigh with thinking enabled.
+        The picker offers off/low/medium/xhigh; released high and max choices
+        normalize to xhigh rather than reaching the strict template unchanged.
+        Template-level off uses chat_template_kwargs.enable_thinking:false.
+        preserve_thinking should stay
         on for an agentic harness (the template's own recommendation for
         agent scenarios; improves KV cache reuse). llama.cpp's own
         reasoning_effort:"none" also disables reasoning at the server layer
         and is a separate mechanism from the template's enable_thinking flag;
-        both were verified independently on llama.cpp and on LM Studio's HTTP
-        port.
+        the none sentinel is consumed before strict template effort validation.
+        LM Studio's HTTP port also accepts none. A 2026-09-05 same-route
+        LiteLLM probe showed none and the template flag alone still reasoned
+        because the generic OpenAI route filtered the effort parameter. Adding
+        allowed_openai_params:["reasoning_effort"] produced zero reasoning
+        twice; an allowed low control still reasoned. Clio forwards only an
+        effort resolved from the model/runtime contract, and never infers the
+        upstream control runtime from a host name, port, or model alias.
 
         Thinking off is verified for this family, and no floor is imposed on
-        it. JetBrains report that Qwen3.8 without reasoning gets stuck in a
+        it. The official card and template were rechecked at revision
+        1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0:
+        https://huggingface.co/Qwen/Qwen3.8-27B/blob/1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0/chat_template.jinja
+        JetBrains report that Qwen3.8 without reasoning gets stuck in a
         loop repeating the same tool call indefinitely under Junie. Clio's
-        shipped default is orchestrator.thinkingLevel: off, which on llama.cpp
+        shipped default is chat.thinkingLevel: off, an explicit Clio preference
+        rather than the vendor's template default. On llama.cpp it
         sends chat_template_kwargs.enable_thinking:false and on LM Studio's
         OpenAI-compatible port sends reasoning_effort:"none". Clio 0.3.8 ran
         that configuration on both runtimes (llama.cpp build b226-2115b73d8 on
@@ -746,8 +762,12 @@
         2026-08-29 and 2026-08-30: an interactive build-and-resume session, a
         three-worker fleet step, and a ten-task eval suite totalling 116 model
         calls, none of which repeated a tool call into a loop. The catalog
-        therefore imposes no thinking floor and coerces no level for this
-        family. If a future build or quantization regresses into the loop
+        therefore imposes no thinking floor for this family. A provisional 2026-09-03 LM Studio A/B on the heavily quantized
+        `qwen3.8-27b-gsq-rco` alias corroborated the switch: four thinking-off
+        scenarios reported zero reasoning tokens and no repeated-tool loop,
+        versus visible reasoning at the active level. The host had LM Link
+        enabled, so this records behavior only—not hardware throughput or a
+        controlled quality claim. If a future build or quantization regresses into the loop
         JetBrains describe, the guards that catch it are Clio's own, not a
         catalog setting: the tool-prose-loop detector
         (src/interactive/tool-prose-loop.ts), which is armed on the
@@ -1695,15 +1715,16 @@
         card's dial is reasoning strength with levels low, medium, high, and
         xhigh, set through the system prompt as "Reasoning strength: <value>",
         and the router passes it as chat_template_kwargs.reasoning_strength
-        pinned to xhigh. There is no off level on that scale, and no
-        ThinkingMechanism in this engine emits that key:
-        resolveRequestCapability populates chat_template_kwargs only with
-        enable_thinking or, on the harmony path, reasoning_effort. Encoding this
-        family as on-off would put a flag on the wire that this template does
-        not read while the TUI showed a working off/on dial, which is the
-        failure qwopus3.5-9b-v3 above was reclassified to stop. A real dial for
-        this family needs a per-family kwarg key in the engine, not a catalog
-        edit.
+        pinned to xhigh. There is no off level on that scale, so the family
+        stays always-on: encoding it as on-off would put an enable_thinking
+        flag on the wire that this template does not read while the TUI showed
+        a working off/on dial, which is the failure qwopus3.5-9b-v3 above was
+        reclassified to stop. The strength dial itself is driven per request:
+        thinking.chatTemplateKwargs.byLevel below maps Clio's thinking level to
+        chat_template_kwargs.reasoning_strength on llama.cpp, and LM Studio,
+        which drops chat_template_kwargs, reports that kwarg as undeliverable
+        instead of sending it. No per-level output has been measured yet, so
+        the always-on classification above stands until one is.
 
         Sampler provenance: temperature 1.0, top_p 0.95 and top_k 64 are the
         card's Best Practices values and the router preset uses the same three.
@@ -1723,7 +1744,7 @@
     gpuTiers:
       "32gb": "Agent-role target on a 32 GB card: UD-Q4_K_XL weights, q8_0 KV at ctx=131072, parallel=1, with the Q8_0 perception encoder and the DFlash drafter both resident."
     runtimePreference:
-      llamaCpp: "OpenAI-compatible chat completions with --jinja. Set the reasoning budget at launch with --chat-template-kwargs {\"reasoning_strength\": \"...\"}; there is no per-request field Clio can send for it."
+      llamaCpp: "OpenAI-compatible chat completions with --jinja. Clio drives the reasoning budget per request through chat_template_kwargs.reasoning_strength, mapped from the thinking level by thinking.chatTemplateKwargs.byLevel; a --chat-template-kwargs launch value is only the server default for requests that send none."
       openaiCompat: "Use when a gateway fronts the same llama.cpp chat-completions surface. Expect a reasoning trace on every response whatever the configured thinking level says."
     llamaCpp:
       ctxSize: 131072
@@ -1742,7 +1763,7 @@
       mechanism: always-on
       chatTemplateKwargs:
         byLevel:
-          # Card: reasoning strength low|medium|high|xhigh (scratchpad/catalog/models/unsloth-Muse-Glimmer-30B.md:35). The per-family kwarg key the note above asked for.
+          # Card: reasoning strength low|medium|high|xhigh (scratchpad/catalog/models/unsloth-Muse-Glimmer-30B.md:35). The per-family kwarg key the note above describes.
           key: reasoning_strength
           values:
             low: low
@@ -1754,9 +1775,10 @@
       guidance: |
         Muse Glimmer reasons on every turn and its strength scale has no off
         level, so Clio shows the dial as forced and budgets for a reasoning
-        preamble ahead of every answer. Change the amount of thinking at the
-        server, with the reasoning_strength chat-template kwarg; a per-request
-        thinking level cannot reach this model.
+        preamble ahead of every answer. The thinking level still sets how much
+        it thinks: on llama.cpp Clio sends reasoning_strength (low, medium,
+        high, xhigh) as a chat-template kwarg per request. LM Studio drops that
+        kwarg, so there the strength stays at the server's own default.
     serving: "Meta Superintelligence Lab Muse-Glimmer-30B, a dense 29.6B causal transformer with a ~1.8B ViT-G/14 perception encoder, interleaved local and global attention with a 2048 sliding window, and a DFlash block-diffusion drafter that proposes 16 tokens per forward pass. Card context length is 131072. Input is text plus image; the mini router additionally tags video, which the card does not claim, so the catalog follows the card."
 
 # ThinkingCap is a brevity finetune of Qwen3.6-27B and not the base model, so it