Merge branch 'task/model-features2' into dev

Author: Snider

go/engine/metal/assistant_dflash.go

@@ -6,7 +6,7 @@ package native
 
 import (
 	core "dappco.re/go"
-	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 )
 
 // assistant_dflash.go is the block-parallel twin of the autoregressive MTP draft
@@ -282,5 +282,5 @@ const (
 // resolveDFlashMethod reports whether a loaded drafter is a DFlash block-diffusion
 // checkpoint — the method the neutral config was stamped with by the reactive spec.
 func resolveDFlashMethod(m *AssistantModel) bool {
-	return m != nil && m.Config.Method == model.MTPDFlash
+	return m != nil && m.Config.Method == mtp.MTPDFlash
 }

go/engine/metal/assistant_dflash_load.go

@@ -12,10 +12,10 @@ import (
 
 // assistant_dflash_load.go builds a DFlashDrafter from a checkpoint on disk. It
 // hand-rolls NO loader: the drafter's decoder stack loads through the ordinary
-// reactive pack loader (LoadAssistantDir → model.ParseAssistantConfig →
+// reactive pack loader (LoadAssistantDir → mtp.ParseAssistantConfig →
 // safetensors.LoadDirMmap), exactly as an MTP -assistant does; the reactive spec
 // (model/gemma4/assistant_dflash.go) recognises the DFlash config and stamps
-// model.MTPDFlash onto the neutral config. This file only reads the DFlash-specific
+// mtp.MTPDFlash onto the neutral config. This file only reads the DFlash-specific
 // parameters the block forward needs — the block size and fused verifier layers via
 // the model-free decode/dflash.ParseConfig contract, and the reduced-vocab d2t map —
 // and validates the DFlash injection tensors the ordinary assistant validation does
@@ -51,7 +51,7 @@ func LoadDFlashDrafter(dir string) (*DFlashDrafter, error) {
 
 // newDFlashDrafter validates a loaded AssistantModel against the DFlash contract and
 // resolves the block forward's parameters. It fails unless the reactive spec stamped
-// model.MTPDFlash (so an ordinary MTP drafter can never be mistaken for a DFlash one)
+// mtp.MTPDFlash (so an ordinary MTP drafter can never be mistaken for a DFlash one)
 // and every DFlash injection tensor is present and correctly shaped.
 func newDFlashDrafter(m *AssistantModel, cfg dflash.Config) (*DFlashDrafter, error) {
 	if m == nil {

go/engine/metal/assistant_dflash_test.go

@@ -11,6 +11,7 @@ import (
 	core "dappco.re/go"
 	"dappco.re/go/inference/decode/dflash"
 	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 	"dappco.re/go/inference/model/safetensors"
 	coreio "dappco.re/go/io"
 )
@@ -64,8 +65,8 @@ func dflashSyntheticDrafter(t testing.TB) (*DFlashDrafter, [][]byte, []byte) {
 		Layer: model.DeriveLayers([]string{"full_attention"}, 0),
 	}
 	m := &AssistantModel{
-		Config: model.AssistantConfig{
-			ModelType: "gemma4_dflash_assistant", Method: model.MTPDFlash,
+		Config: mtp.AssistantConfig{
+			ModelType: "gemma4_dflash_assistant", Method: mtp.MTPDFlash,
 			BackboneHidden: dflBackbone, Arch: arch, LayerTypes: []string{"full_attention"},
 		},
 		Arch:               arch,

go/engine/metal/assistant_gguf.go

@@ -7,7 +7,7 @@ package native
 import (
 	core "dappco.re/go"
 	"dappco.re/go/inference/decode/tokenizer"
-	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 	"dappco.re/go/inference/model/gguf"
 	"dappco.re/go/inference/model/safetensors"
 	coreio "dappco.re/go/io"
@@ -48,7 +48,7 @@ func nativeHasGGUFSuffix(path string) bool {
 
 // loadNativeAssistantFromGGUF loads a single-file GGUF drafter export through the
 // reactive assistant registry: general.architecture picks the registered model package's
-// spec (model.RegisterAssistant), whose weight-name map and metadata parser turn the GGUF
+// spec (mtp.RegisterAssistant), whose weight-name map and metadata parser turn the GGUF
 // into the same neutral config + canonical tensor names the safetensors path produces —
 // the engine itself knows nothing about any drafter's format.
 func loadNativeAssistantFromGGUF(file string, tok *tokenizer.Tokenizer) (*AssistantModel, error) {
@@ -60,7 +60,7 @@ func loadNativeAssistantFromGGUF(file string, tok *tokenizer.Tokenizer) (*Assist
 		return nil, core.E("native.assistant.gguf", "read gguf metadata", err)
 	}
 	arch, _ := meta["general.architecture"].(string)
-	spec, ok := model.LookupAssistantGGUF(arch)
+	spec, ok := mtp.LookupAssistantGGUF(arch)
 	if !ok {
 		return nil, core.E("native.assistant.gguf", "no registered assistant spec for gguf architecture "+arch, nil)
 	}
@@ -76,7 +76,7 @@ func loadNativeAssistantFromGGUF(file string, tok *tokenizer.Tokenizer) (*Assist
 	return m, nil
 }
 
-func buildNativeAssistantFromGGUFTensors(spec model.AssistantSpec, meta map[string]any, raw *gguf.TensorMapping, tok *tokenizer.Tokenizer) (*AssistantModel, error) {
+func buildNativeAssistantFromGGUFTensors(spec mtp.AssistantSpec, meta map[string]any, raw *gguf.TensorMapping, tok *tokenizer.Tokenizer) (*AssistantModel, error) {
 	if raw == nil {
 		return nil, core.NewError("native.assistant.gguf tensor map is nil")
 	}

go/engine/metal/assistant_load.go

@@ -15,6 +15,7 @@ import (
 	"dappco.re/go/inference/decode/tokenizer"
 	"dappco.re/go/inference/model"
 	"dappco.re/go/inference/model/gguf"
+	"dappco.re/go/inference/model/mtp"
 	"dappco.re/go/inference/model/safetensors"
 	coreio "dappco.re/go/io"
 	"github.com/tmc/apple/metal"
@@ -38,11 +39,11 @@ var nativeAssistantByteScratchPools sync.Map
 // AssistantModel is the native, CGO-free assistant-only checkpoint
 // handle. The decode integration uses the mmap-backed tensors directly in a
 // later slice; this loader owns the mmap and validates the attached-drafter
-// tensor layout up front. The config arrives as the NEUTRAL model.AssistantConfig
-// a registered model package parsed (model.RegisterAssistant) — the engine never
+// tensor layout up front. The config arrives as the NEUTRAL mtp.AssistantConfig
+// a registered model package parsed (mtp.RegisterAssistant) — the engine never
 // keys on which model family the drafter belongs to.
 type AssistantModel struct {
-	Config                   model.AssistantConfig
+	Config                   mtp.AssistantConfig
 	Arch                     model.Arch
 	Tensors                  map[string]safetensors.Tensor
 	BackboneHiddenSize       int
@@ -97,18 +98,18 @@ type AssistantPair struct {
 }
 
 // Method reports the speculative-decode method inferred from the drafter (see
-// model.MTPMethod), so the decode driver dispatches on the method rather than
+// mtp.MTPMethod), so the decode driver dispatches on the method rather than
 // assuming the separate draft-model path. An unstamped config (e.g. a GGUF load
-// that has not carried the field) defaults to model.MTPDraftModel — the only
+// that has not carried the field) defaults to mtp.MTPDraftModel — the only
 // method shipped today.
-func (pair *AssistantPair) Method() model.MTPMethod {
+func (pair *AssistantPair) Method() mtp.MTPMethod {
 	if pair == nil || pair.Assistant == nil {
-		return model.MTPDraftModel
+		return mtp.MTPDraftModel
 	}
 	if m := pair.Assistant.Config.Method; m != "" {
 		return m
 	}
-	return model.MTPDraftModel
+	return mtp.MTPDraftModel
 }
 
 // AssistantDraftStepResult is one native assistant proposal from a target
@@ -376,8 +377,8 @@ func LoadAssistantDir(dir string) (*AssistantModel, error) {
 		return nil, core.E("native.assistant.Load", "read config.json", err)
 	}
 	// the reactive parse: probe model_type → the registered model package's parser
-	// (model.RegisterAssistant) → the neutral, already-validated config + derived arch.
-	cfg, err := model.ParseAssistantConfig([]byte(cfgStr))
+	// (mtp.RegisterAssistant) → the neutral, already-validated config + derived arch.
+	cfg, err := mtp.ParseAssistantConfig([]byte(cfgStr))
 	if err != nil {
 		return nil, core.E("native.assistant.Load", "parse config", err)
 	}
@@ -731,7 +732,7 @@ func (m *AssistantModel) ModelType() string {
 	// report the claiming spec's CANONICAL id (its first ModelTypes entry) so checkpoint
 	// variants (e.g. a unified assistant) normalise to the public id their model package
 	// declares — the registry is the normalisation table, never a hardcoded model list.
-	if spec, ok := model.LookupAssistant(m.Config.ModelType); ok && len(spec.ModelTypes) > 0 && spec.ModelTypes[0] != "" {
+	if spec, ok := mtp.LookupAssistant(m.Config.ModelType); ok && len(spec.ModelTypes) > 0 && spec.ModelTypes[0] != "" {
 		return spec.ModelTypes[0]
 	}
 	return m.Config.ModelType

go/engine/metal/assistant_load_test.go

@@ -18,6 +18,7 @@ import (
 	core "dappco.re/go"
 	"dappco.re/go/inference/model"
 	"dappco.re/go/inference/model/gguf"
+	"dappco.re/go/inference/model/mtp"
 	"dappco.re/go/inference/model/safetensors"
 	coreio "dappco.re/go/io"
 )
@@ -4200,7 +4201,7 @@ func TestNativeAssistantDequantizeTensors_Good(t *testing.T) {
 	want := f32ToBf16Slice(wantF32)
 
 	m := &AssistantModel{
-		Config: model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: groupSize, Bits: bits}},
+		Config: mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: groupSize, Bits: bits}},
 		Tensors: map[string]safetensors.Tensor{
 			"layer.weight": {Dtype: "U32", Shape: []int{rows, words}, Data: packed},
 			"layer.scales": {Dtype: "BF16", Shape: []int{rows, cols / groupSize}, Data: scales},
@@ -4238,7 +4239,7 @@ func TestNativeAssistantDequantizeTensors_Bad(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			m := &AssistantModel{
-				Config: model.AssistantConfig{Quant: &c.quant},
+				Config: mtp.AssistantConfig{Quant: &c.quant},
 				Tensors: map[string]safetensors.Tensor{
 					"layer.weight": {Dtype: "U32", Shape: c.shape, Data: make([]byte, 4)},
 					"layer.scales": {Dtype: "BF16", Shape: []int{1, 1}, Data: make([]byte, 2)},
@@ -4266,7 +4267,7 @@ func TestNativeAssistantDequantizeTensors_Ugly(t *testing.T) {
 	})
 	t.Run("non_affine_mode_is_noop", func(t *testing.T) {
 		m := &AssistantModel{
-			Config:  model.AssistantConfig{Quant: &model.QuantConfig{Mode: "mxfp4", GroupSize: 4, Bits: 4}},
+			Config:  mtp.AssistantConfig{Quant: &model.QuantConfig{Mode: "mxfp4", GroupSize: 4, Bits: 4}},
 			Tensors: map[string]safetensors.Tensor{"layer.weight": untouched},
 		}
 		if err := nativeAssistantDequantizeTensors(m); err != nil {
@@ -4278,7 +4279,7 @@ func TestNativeAssistantDequantizeTensors_Ugly(t *testing.T) {
 	})
 	t.Run("missing_sibling_is_skipped", func(t *testing.T) {
 		m := &AssistantModel{
-			Config: model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
+			Config: mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
 			Tensors: map[string]safetensors.Tensor{
 				"layer.weight": untouched,
 				"layer.scales": {Dtype: "BF16", Shape: []int{1, 1}, Data: make([]byte, 2)},
@@ -4294,7 +4295,7 @@ func TestNativeAssistantDequantizeTensors_Ugly(t *testing.T) {
 	})
 	t.Run("wrong_rank_is_skipped", func(t *testing.T) {
 		m := &AssistantModel{
-			Config: model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
+			Config: mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
 			Tensors: map[string]safetensors.Tensor{
 				"layer.weight": {Dtype: "U32", Shape: []int{4}, Data: make([]byte, 4)},
 				"layer.scales": {Dtype: "BF16", Shape: []int{1}, Data: make([]byte, 2)},
@@ -4323,9 +4324,9 @@ func TestNativeAssistantLinearInputMatches_Bad(t *testing.T) {
 		m    *AssistantModel
 	}{
 		{"quant_nil", &AssistantModel{}},
-		{"bits_zero", &AssistantModel{Config: model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4}}}},
+		{"bits_zero", &AssistantModel{Config: mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4}}}},
 		{"missing_scales", &AssistantModel{
-			Config:  model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
+			Config:  mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
 			Tensors: map[string]safetensors.Tensor{},
 		}},
 	}
@@ -4342,7 +4343,7 @@ func TestNativeAssistantLinearInputMatches_Ugly(t *testing.T) {
 	// bits=4 packs 8 codes/word (packFactor=32/4=8): wantIn=8 divides evenly,
 	// so a packed gotIn of wantIn/packFactor=1 word is accepted.
 	packed := &AssistantModel{
-		Config:  model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
+		Config:  mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 4}},
 		Tensors: map[string]safetensors.Tensor{"layer.scales": {Dtype: "BF16", Data: make([]byte, 2)}},
 	}
 	if !nativeAssistantLinearInputMatches(packed, "layer", 1, 8) {
@@ -4351,7 +4352,7 @@ func TestNativeAssistantLinearInputMatches_Ugly(t *testing.T) {
 	// bits=3: packFactor=32/3=10 does not divide wantIn=8, so the packer falls
 	// back to the byte-packed-row formula gotIn == (wantIn*bits+31)/32.
 	fallback := &AssistantModel{
-		Config:  model.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 3}},
+		Config:  mtp.AssistantConfig{Quant: &model.QuantConfig{GroupSize: 4, Bits: 3}},
 		Tensors: map[string]safetensors.Tensor{"layer.scales": {Dtype: "BF16", Data: make([]byte, 2)}},
 	}
 	const wantIn = 8

go/engine/metal/assistant_synthetic_session_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 	"dappco.re/go/inference/model/safetensors"
 )
 
@@ -119,8 +120,8 @@ func synthTokensInVocab(t *testing.T, what string, ids []int32) {
 
 func TestSyntheticAssistantPairMethodAndPrepareAssistantPrompt(t *testing.T) {
 	sess, pair, prompt := newSyntheticAssistantPair(t)
-	if m := pair.Method(); m != model.MTPDraftModel {
-		t.Fatalf("Method = %q, want %q (unstamped config defaults to draft-model)", m, model.MTPDraftModel)
+	if m := pair.Method(); m != mtp.MTPDraftModel {
+		t.Fatalf("Method = %q, want %q (unstamped config defaults to draft-model)", m, mtp.MTPDraftModel)
 	}
 	if err := sess.PrepareAssistantPrompt(prompt); err != nil {
 		t.Fatalf("PrepareAssistantPrompt: %v", err)

go/engine/metal/speculative_model.go

@@ -30,6 +30,7 @@ import (
 	"dappco.re/go/inference/decode/tokenizer"
 	"dappco.re/go/inference/engine"
 	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 	coreio "dappco.re/go/io"
 )
 
@@ -102,7 +103,7 @@ func LoadSpeculativePair(targetPath, draftPath string, draftBlock int, opts ...i
 		return nil, core.E("native.LoadSpeculativePair", "attach drafter", err)
 	}
 	var dflashDrafter *DFlashDrafter
-	if pair.Method() == model.MTPDFlash {
+	if pair.Method() == mtp.MTPDFlash {
 		cfgJSON, readErr := coreio.Local.Read(core.PathJoin(draftPath, "config.json"))
 		if readErr != nil {
 			_ = target.Close()
@@ -252,11 +253,11 @@ func (m *speculativeModel) speculate(ctx context.Context, ids []int32, cfg infer
 // independent of either engine loop lets scripted-engine tests prove that the
 // pair's declared method, rather than checkpoint naming or caller state, is the
 // sole routing input.
-func speculativeMethodRoute(pair *AssistantPair, mtp, dfl func() (AssistantGenerateResult, error)) (AssistantGenerateResult, error) {
-	if pair != nil && pair.Method() == model.MTPDFlash {
+func speculativeMethodRoute(pair *AssistantPair, runMTP, dfl func() (AssistantGenerateResult, error)) (AssistantGenerateResult, error) {
+	if pair != nil && pair.Method() == mtp.MTPDFlash {
 		return dfl()
 	}
-	return mtp()
+	return runMTP()
 }
 
 // generateDFlash drives the block-diffusion proposer through the model-free,

go/engine/metal/speculative_model_test.go

@@ -15,7 +15,7 @@ import (
 	"dappco.re/go/inference"
 	"dappco.re/go/inference/decode/tokenizer"
 	"dappco.re/go/inference/engine"
-	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/mtp"
 )
 
 func speculativeTestTokenizer(t *testing.T) *tokenizer.Tokenizer {
@@ -264,7 +264,7 @@ func TestSpeculativeChatFraming(t *testing.T) {
 // TestDFlashSpeculativeMethodRoute proves a DFlash-stamped pair selects the
 // block-diffusion driver and never enters the legacy MTP loop.
 func TestDFlashSpeculativeMethodRoute(t *testing.T) {
-	pair := &AssistantPair{Assistant: &AssistantModel{Config: model.AssistantConfig{Method: model.MTPDFlash}}}
+	pair := &AssistantPair{Assistant: &AssistantModel{Config: mtp.AssistantConfig{Method: mtp.MTPDFlash}}}
 	mtpCalls, dflashCalls := 0, 0
 	got, err := speculativeMethodRoute(pair,
 		func() (AssistantGenerateResult, error) {
@@ -286,8 +286,8 @@ func TestDFlashSpeculativeMethodRoute(t *testing.T) {
 // TestDFlashSpeculativeMethodRouteKeepsMTP pins the pre-existing MTP behaviour:
 // explicit MTP and the historical unstamped default both select only that loop.
 func TestDFlashSpeculativeMethodRouteKeepsMTP(t *testing.T) {
-	for _, method := range []model.MTPMethod{model.MTPDraftModel, ""} {
-		pair := &AssistantPair{Assistant: &AssistantModel{Config: model.AssistantConfig{Method: method}}}
+	for _, method := range []mtp.MTPMethod{mtp.MTPDraftModel, ""} {
+		pair := &AssistantPair{Assistant: &AssistantModel{Config: mtp.AssistantConfig{Method: method}}}
 		mtpCalls, dflashCalls := 0, 0
 		got, err := speculativeMethodRoute(pair,
 			func() (AssistantGenerateResult, error) {

go/engine/metal/token_model.go

@@ -11,6 +11,7 @@ import (
 	"dappco.re/go/inference/decode/tokenizer"
 	"dappco.re/go/inference/engine"
 	"dappco.re/go/inference/model"
+	"dappco.re/go/inference/model/vision"
 )
 
 // NativeTokenModel binds the no-cgo decode backend + the embed/head bookend
@@ -58,10 +59,10 @@ type NativeTokenModel struct {
 	// uses the upload closure). Concurrency-safe (no shared mutable state), so the shared model can
 	// serve many request goroutines. Set by LoadGemma4TokenModelDir.
 	headEnc *headEncoder
-	vision  *model.LoadedVision
+	vision  *vision.Loaded
 	// unifiedVision is the encoder-free vision embedder (gemma4_unified, 12B):
 	// packs carry either the SigLIP tower (vision) or this — never both.
-	unifiedVision *model.LoadedUnifiedVision
+	unifiedVision *vision.Unified
 	// visionFeatureCfg is the image_processor preprocessing config (patch size,
 	// soft-token budget, pooling, rescale) read from processor_config.json at load
 	// time — ProjectImage needs it to patchify before the tower. nil for a
@@ -514,7 +515,7 @@ func (m *NativeTokenModel) spliceTokenFeaturesInto(stream []byte, tokenIDs []int
 	return nil
 }
 
-func nativeVisionFromLoaded(loaded *model.LoadedVision) (*VisionWeights, VisionConfig, bool) {
+func nativeVisionFromLoaded(loaded *vision.Loaded) (*VisionWeights, VisionConfig, bool) {
 	if loaded == nil {
 		return nil, VisionConfig{}, false
 	}
@@ -585,7 +586,7 @@ func nativeVisionFromLoaded(loaded *model.LoadedVision) (*VisionWeights, VisionC
 	return weights, cfg, true
 }
 
-func nativeVisionProjectorLinear(l model.LoadedVisionLinear) VisionProjectorLinear {
+func nativeVisionProjectorLinear(l vision.Linear) VisionProjectorLinear {
 	return VisionProjectorLinear{
 		Weight:    l.Weight,
 		Scales:    l.Scales,