Update docs

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

app/ui/app/src/hooks/useChats.ts

@@ -381,7 +381,7 @@ export const useSendMessage = (chatId: string) => {
                     role: "assistant",
                     content: "",
                     thinking: "",
-                    model: effectiveModel.model,
+                    model: effectiveModel,
                   }),
                 );
                 lastMessage = newMessages[newMessages.length - 1];
@@ -433,7 +433,7 @@ export const useSendMessage = (chatId: string) => {
                     role: "assistant",
                     content: "",
                     thinking: "",
-                    model: effectiveModel.model,
+                    model: effectiveModel,
                   }),
                 );
                 lastMessage = newMessages[newMessages.length - 1];
@@ -520,7 +520,7 @@ export const useSendMessage = (chatId: string) => {
                     thinkingTimeStart:
                       lastMessage.thinkingTimeStart || event.thinkingTimeStart,
                     thinkingTimeEnd: event.thinkingTimeEnd,
-                    model: selectedModel.model,
+                    model: selectedModel,
                   });
                   newMessages[newMessages.length - 1] = updatedMessage;
                 } else {
@@ -533,7 +533,7 @@ export const useSendMessage = (chatId: string) => {
                       tool_calls: event.toolCalls,
                       thinkingTimeStart: event.thinkingTimeStart,
                       thinkingTimeEnd: event.thinkingTimeEnd,
-                      model: selectedModel.model,
+                      model: selectedModel,
                     }),
                   );
                 }
@@ -699,7 +699,7 @@ export const useSendMessage = (chatId: string) => {
             queryClient.setQueryData(["chat", newId], {
               chat: new Chat({
                 id: newId,
-                model: effectiveModel.model,
+                model: effectiveModel,
                 messages: [
                   new Message({
                     role: "user",

cmd/cmd.go

@@ -1975,61 +1975,8 @@ func launchInteractiveModel(cmd *cobra.Command, modelName string) error {
 		Options:     map[string]any{},
 		ShowConnect: true,
 	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-
-	requestedCloud := modelref.HasExplicitCloudSource(modelName)
-
-	info, err := func() (*api.ShowResponse, error) {
-		showReq := &api.ShowRequest{Name: modelName}
-		info, err := client.Show(cmd.Context(), showReq)
-		var se api.StatusError
-		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
-			if requestedCloud {
-				return nil, err
-			}
-			if err := PullHandler(cmd, []string{modelName}); err != nil {
-				return nil, err
-			}
-			return client.Show(cmd.Context(), &api.ShowRequest{Name: modelName})
-		}
-		return info, err
-	}()
-	if err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
-		return err
-	}
-
-	ensureCloudStub(cmd.Context(), client, modelName)
-
-	opts.Think, err = inferThinkingOption(&info.Capabilities, &opts, false)
-	if err != nil {
-		return err
-	}
-
-	audioCapable := slices.Contains(info.Capabilities, model.CapabilityAudio)
-	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision) || audioCapable
-
-	// TODO: remove the projector info and vision info checks below,
-	// these are left in for backwards compatibility with older servers
-	// that don't have the capabilities field in the model info
-	if len(info.ProjectorInfo) != 0 {
-		opts.MultiModal = true
-	}
-	for k := range info.ModelInfo {
-		if strings.Contains(k, ".vision.") {
-			opts.MultiModal = true
-			break
-		}
-	}
-
-	applyShowResponseToRunOptions(&opts, info)
-
+	// loadOrUnloadModel is cloud-safe here: remote/cloud models skip local preload
+	// and only validate auth/connectivity before interactive chat starts.
 	if err := loadOrUnloadModel(cmd, &opts); err != nil {
 		return fmt.Errorf("error loading model: %w", err)
 	}

cmd/launch/codex.go

@@ -1,20 +1,13 @@
 package launch
 
 import (
-	"context"
-	"encoding/json"
 	"fmt"
-	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"slices"
-	"strconv"
 	"strings"
 
-	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/types/model"
 	"golang.org/x/mod/semver"
 )
 
@@ -39,7 +32,7 @@ func (c *Codex) Run(model string, args []string) error {
 		return err
 	}
 
-	if err := ensureCodexConfig(model); err != nil {
+	if err := ensureCodexConfig(); err != nil {
 		return fmt.Errorf("failed to configure codex: %w", err)
 	}
 
@@ -53,9 +46,9 @@ func (c *Codex) Run(model string, args []string) error {
 	return cmd.Run()
 }
 
-// ensureCodexConfig writes a Codex profile and model catalog so Codex uses the
-// local Ollama server and has model metadata available.
-func ensureCodexConfig(modelName string) error {
+// ensureCodexConfig writes a [profiles.ollama-launch] section to ~/.codex/config.toml
+// with openai_base_url pointing to the local Ollama server.
+func ensureCodexConfig() error {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return err
@@ -66,18 +59,13 @@ func ensureCodexConfig(modelName string) error {
 		return err
 	}
 
-	catalogPath := filepath.Join(codexDir, "model.json")
-	if err := writeCodexModelCatalog(catalogPath, modelName); err != nil {
-		return err
-	}
-
 	configPath := filepath.Join(codexDir, "config.toml")
-	return writeCodexProfile(configPath, catalogPath)
+	return writeCodexProfile(configPath)
 }
 
 // writeCodexProfile ensures ~/.codex/config.toml has the ollama-launch profile
 // and model provider sections with the correct base URL.
-func writeCodexProfile(configPath, catalogPath string) error {
+func writeCodexProfile(configPath string) error {
 	baseURL := envconfig.Host().String() + "/v1/"
 
 	sections := []struct {
@@ -90,7 +78,6 @@ func writeCodexProfile(configPath, catalogPath string) error {
 				fmt.Sprintf("openai_base_url = %q", baseURL),
 				`forced_login_method = "api"`,
 				fmt.Sprintf("model_provider = %q", codexProfileName),
-				fmt.Sprintf("model_catalog_json = %q", catalogPath),
 			},
 		},
 		{
@@ -134,110 +121,6 @@ func writeCodexProfile(configPath, catalogPath string) error {
 	return os.WriteFile(configPath, []byte(text), 0o644)
 }
 
-func writeCodexModelCatalog(catalogPath, modelName string) error {
-	entry := buildCodexModelEntry(modelName)
-
-	catalog := map[string]any{
-		"models": []any{entry},
-	}
-
-	data, err := json.MarshalIndent(catalog, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	return os.WriteFile(catalogPath, data, 0o644)
-}
-
-func buildCodexModelEntry(modelName string) map[string]any {
-	contextWindow := 0
-	hasVision := false
-	hasThinking := false
-	systemPrompt := ""
-
-	if l, ok := lookupCloudModelLimit(modelName); ok {
-		contextWindow = l.Context
-	}
-
-	client := api.NewClient(envconfig.Host(), http.DefaultClient)
-	resp, err := client.Show(context.Background(), &api.ShowRequest{Model: modelName})
-	if err == nil {
-		systemPrompt = resp.System
-		if slices.Contains(resp.Capabilities, model.CapabilityVision) {
-			hasVision = true
-		}
-		if slices.Contains(resp.Capabilities, model.CapabilityThinking) {
-			hasThinking = true
-		}
-
-		if !isCloudModelName(modelName) {
-			if n, ok := modelInfoContextLength(resp.ModelInfo); ok {
-				contextWindow = n
-			}
-			if resp.Details.Format != "safetensors" {
-				if ctxLen := envconfig.ContextLength(); ctxLen > 0 {
-					contextWindow = int(ctxLen)
-				}
-				if numCtx := parseNumCtx(resp.Parameters); numCtx > 0 {
-					contextWindow = numCtx
-				}
-			}
-		}
-	}
-
-	modalities := []string{"text"}
-	if hasVision {
-		modalities = append(modalities, "image")
-	}
-
-	reasoningLevels := []any{}
-	if hasThinking {
-		reasoningLevels = []any{
-			map[string]any{"effort": "low", "description": "Fast responses with lighter reasoning"},
-			map[string]any{"effort": "medium", "description": "Balances speed and reasoning depth"},
-			map[string]any{"effort": "high", "description": "Greater reasoning depth for complex problems"},
-		}
-	}
-
-	truncationMode := "bytes"
-	if isCloudModelName(modelName) {
-		truncationMode = "tokens"
-	}
-
-	return map[string]any{
-		"slug":                         modelName,
-		"display_name":                 modelName,
-		"context_window":               contextWindow,
-		"apply_patch_tool_type":        "function",
-		"shell_type":                   "default",
-		"visibility":                   "list",
-		"supported_in_api":             true,
-		"priority":                     0,
-		"truncation_policy":            map[string]any{"mode": truncationMode, "limit": 10000},
-		"input_modalities":             modalities,
-		"base_instructions":            systemPrompt,
-		"support_verbosity":            true,
-		"default_verbosity":            "low",
-		"supports_parallel_tool_calls": false,
-		"supports_reasoning_summaries": hasThinking,
-		"supported_reasoning_levels":   reasoningLevels,
-		"experimental_supported_tools": []any{},
-	}
-}
-
-func parseNumCtx(parameters string) int {
-	for _, line := range strings.Split(parameters, "\n") {
-		fields := strings.Fields(line)
-		if len(fields) == 2 && fields[0] == "num_ctx" {
-			if v, err := strconv.ParseFloat(fields[1], 64); err == nil {
-				return int(v)
-			}
-		}
-	}
-
-	return 0
-}
-
 func checkCodexVersion() error {
 	if _, err := exec.LookPath("codex"); err != nil {
 		return fmt.Errorf("codex is not installed, install with: npm install -g @openai/codex")

cmd/launch/codex_test.go

@@ -1,10 +1,6 @@
 package launch
 
 import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"slices"
@@ -41,9 +37,8 @@ func TestWriteCodexProfile(t *testing.T) {
 	t.Run("creates new file when none exists", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -68,9 +63,6 @@ func TestWriteCodexProfile(t *testing.T) {
 		if !strings.Contains(content, `model_provider = "ollama-launch"`) {
 			t.Error("missing model_provider key")
 		}
-		if !strings.Contains(content, fmt.Sprintf("model_catalog_json = %q", catalogPath)) {
-			t.Error("missing model_catalog_json key")
-		}
 		if !strings.Contains(content, "[model_providers.ollama-launch]") {
 			t.Error("missing [model_providers.ollama-launch] section")
 		}
@@ -82,11 +74,10 @@ func TestWriteCodexProfile(t *testing.T) {
 	t.Run("appends profile to existing file without profile", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 		existing := "[some_other_section]\nkey = \"value\"\n"
 		os.WriteFile(configPath, []byte(existing), 0o644)
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -104,11 +95,10 @@ func TestWriteCodexProfile(t *testing.T) {
 	t.Run("replaces existing profile section", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 		existing := "[profiles.ollama-launch]\nopenai_base_url = \"http://old:1234/v1/\"\n\n[model_providers.ollama-launch]\nname = \"Ollama\"\nbase_url = \"http://old:1234/v1/\"\n"
 		os.WriteFile(configPath, []byte(existing), 0o644)
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -129,11 +119,10 @@ func TestWriteCodexProfile(t *testing.T) {
 	t.Run("replaces profile while preserving following sections", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 		existing := "[profiles.ollama-launch]\nopenai_base_url = \"http://old:1234/v1/\"\n[another_section]\nfoo = \"bar\"\n"
 		os.WriteFile(configPath, []byte(existing), 0o644)
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -154,11 +143,10 @@ func TestWriteCodexProfile(t *testing.T) {
 	t.Run("appends newline to file not ending with newline", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 		existing := "[other]\nkey = \"val\""
 		os.WriteFile(configPath, []byte(existing), 0o644)
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -178,9 +166,8 @@ func TestWriteCodexProfile(t *testing.T) {
 		t.Setenv("OLLAMA_HOST", "http://myhost:9999")
 		tmpDir := t.TempDir()
 		configPath := filepath.Join(tmpDir, "config.toml")
-		catalogPath := filepath.Join(tmpDir, "model.json")
 
-		if err := writeCodexProfile(configPath, catalogPath); err != nil {
+		if err := writeCodexProfile(configPath); err != nil {
 			t.Fatal(err)
 		}
 
@@ -198,7 +185,7 @@ func TestEnsureCodexConfig(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)
 
-		if err := ensureCodexConfig("llama3.2"); err != nil {
+		if err := ensureCodexConfig(); err != nil {
 			t.Fatal(err)
 		}
 
@@ -215,25 +202,16 @@ func TestEnsureCodexConfig(t *testing.T) {
 		if !strings.Contains(content, "openai_base_url") {
 			t.Error("missing openai_base_url key")
 		}
-
-		catalogPath := filepath.Join(tmpDir, ".codex", "model.json")
-		data, err = os.ReadFile(catalogPath)
-		if err != nil {
-			t.Fatalf("model.json not created: %v", err)
-		}
-		if !strings.Contains(string(data), `"slug": "llama3.2"`) {
-			t.Error("missing model catalog entry for selected model")
-		}
 	})
 
 	t.Run("is idempotent", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)
 
-		if err := ensureCodexConfig("llama3.2"); err != nil {
+		if err := ensureCodexConfig(); err != nil {
 			t.Fatal(err)
 		}
-		if err := ensureCodexConfig("llama3.2"); err != nil {
+		if err := ensureCodexConfig(); err != nil {
 			t.Fatal(err)
 		}
 
@@ -249,204 +227,3 @@ func TestEnsureCodexConfig(t *testing.T) {
 		}
 	})
 }
-
-func TestParseNumCtx(t *testing.T) {
-	tests := []struct {
-		name       string
-		parameters string
-		want       int
-	}{
-		{"num_ctx set", "num_ctx 8192", 8192},
-		{"num_ctx with other params", "temperature 0.7\nnum_ctx 4096\ntop_p 0.9", 4096},
-		{"no num_ctx", "temperature 0.7\ntop_p 0.9", 0},
-		{"empty string", "", 0},
-		{"malformed value", "num_ctx abc", 0},
-		{"float value", "num_ctx 8192.0", 8192},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := parseNumCtx(tt.parameters); got != tt.want {
-				t.Errorf("parseNumCtx(%q) = %d, want %d", tt.parameters, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestModelInfoContextLength(t *testing.T) {
-	tests := []struct {
-		name      string
-		modelInfo map[string]any
-		want      int
-	}{
-		{"float64 value", map[string]any{"qwen3_5_moe.context_length": float64(262144)}, 262144},
-		{"int value", map[string]any{"llama.context_length": 131072}, 131072},
-		{"no context_length key", map[string]any{"llama.embedding_length": float64(4096)}, 0},
-		{"empty map", map[string]any{}, 0},
-		{"nil map", nil, 0},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, _ := modelInfoContextLength(tt.modelInfo)
-			if got != tt.want {
-				t.Errorf("modelInfoContextLength() = %d, want %d", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestBuildCodexModelEntryContextWindow(t *testing.T) {
-	tests := []struct {
-		name          string
-		modelName     string
-		showResponse  string
-		envContextLen string
-		wantContext   int
-	}{
-		{
-			name:      "architectural context length as fallback",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"details": {"format": "gguf"}
-			}`,
-			wantContext: 131072,
-		},
-		{
-			name:      "OLLAMA_CONTEXT_LENGTH overrides architectural",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"details": {"format": "gguf"}
-			}`,
-			envContextLen: "64000",
-			wantContext:   64000,
-		},
-		{
-			name:      "num_ctx overrides OLLAMA_CONTEXT_LENGTH",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"parameters": "num_ctx 8192",
-				"details": {"format": "gguf"}
-			}`,
-			envContextLen: "64000",
-			wantContext:   8192,
-		},
-		{
-			name:      "num_ctx overrides architectural",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"parameters": "num_ctx 32768",
-				"details": {"format": "gguf"}
-			}`,
-			wantContext: 32768,
-		},
-		{
-			name:      "safetensors uses architectural context only",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"parameters": "num_ctx 8192",
-				"details": {"format": "safetensors"}
-			}`,
-			envContextLen: "64000",
-			wantContext:   131072,
-		},
-		{
-			name:      "cloud model uses hardcoded limits",
-			modelName: "qwen3.5:cloud",
-			showResponse: `{
-				"model_info": {"qwen3_5_moe.context_length": 131072},
-				"details": {"format": "gguf"}
-			}`,
-			envContextLen: "64000",
-			wantContext:   262144,
-		},
-		{
-			name:      "vision and thinking capabilities",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"details": {"format": "gguf"},
-				"capabilities": ["vision", "thinking"]
-			}`,
-			wantContext: 131072,
-		},
-		{
-			name:      "system prompt passed through",
-			modelName: "llama3.2",
-			showResponse: `{
-				"model_info": {"llama.context_length": 131072},
-				"details": {"format": "gguf"},
-				"system": "You are a helpful assistant."
-			}`,
-			wantContext: 131072,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				switch r.URL.Path {
-				case "/api/show":
-					fmt.Fprint(w, tt.showResponse)
-				default:
-					http.NotFound(w, r)
-				}
-			}))
-			defer srv.Close()
-			t.Setenv("OLLAMA_HOST", srv.URL)
-
-			if tt.envContextLen != "" {
-				t.Setenv("OLLAMA_CONTEXT_LENGTH", tt.envContextLen)
-			} else {
-				t.Setenv("OLLAMA_CONTEXT_LENGTH", "")
-			}
-
-			entry := buildCodexModelEntry(tt.modelName)
-
-			gotContext, _ := entry["context_window"].(int)
-			if gotContext != tt.wantContext {
-				t.Errorf("context_window = %d, want %d", gotContext, tt.wantContext)
-			}
-
-			if tt.name == "vision and thinking capabilities" {
-				modalities, _ := entry["input_modalities"].([]string)
-				if !slices.Contains(modalities, "image") {
-					t.Error("expected image in input_modalities")
-				}
-				levels, _ := entry["supported_reasoning_levels"].([]any)
-				if len(levels) == 0 {
-					t.Error("expected non-empty supported_reasoning_levels")
-				}
-			}
-
-			if tt.name == "system prompt passed through" {
-				if got, _ := entry["base_instructions"].(string); got != "You are a helpful assistant." {
-					t.Errorf("base_instructions = %q, want %q", got, "You are a helpful assistant.")
-				}
-			}
-
-			if tt.name == "cloud model uses hardcoded limits" {
-				truncationPolicy, _ := entry["truncation_policy"].(map[string]any)
-				if mode, _ := truncationPolicy["mode"].(string); mode != "tokens" {
-					t.Errorf("truncation_policy mode = %q, want %q", mode, "tokens")
-				}
-			}
-
-			requiredKeys := []string{"slug", "display_name", "apply_patch_tool_type", "shell_type"}
-			for _, key := range requiredKeys {
-				if _, ok := entry[key]; !ok {
-					t.Errorf("missing required key %q", key)
-				}
-			}
-
-			if _, err := json.Marshal(entry); err != nil {
-				t.Errorf("entry is not JSON serializable: %v", err)
-			}
-		})
-	}
-}

cmd/launch/command_test.go

@@ -61,9 +61,6 @@ func TestLaunchCmd(t *testing.T) {
 		if !strings.Contains(cmd.Long, "hermes") {
 			t.Error("Long description should mention hermes")
 		}
-		if !strings.Contains(cmd.Long, "kimi") {
-			t.Error("Long description should mention kimi")
-		}
 	})
 
 	t.Run("flags exist", func(t *testing.T) {

cmd/launch/hermes.go

@@ -4,15 +4,18 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"os"
 	"os/exec"
+	pathpkg "path"
 	"path/filepath"
 	"runtime"
 	"slices"
 	"strconv"
 	"strings"
+	"time"
 
 	"gopkg.in/yaml.v3"
 
@@ -63,13 +66,23 @@ var hermesMessagingEnvGroups = [][]string{
 // switching UX after startup.
 type Hermes struct{}
 
+type hermesConfigBackend struct {
+	displayPath string
+	read        func() ([]byte, error)
+	write       func([]byte) error
+}
+
 func (h *Hermes) String() string { return "Hermes Agent" }
 
 func (h *Hermes) Run(_ string, args []string) error {
 	// Hermes reads its primary model from config.yaml. launch configures that
 	// default model ahead of time so we can keep runtime invocation simple and
 	// still let Hermes discover additional models later via its own UX.
-	bin, err := h.binary()
+	if hermesGOOS == "windows" {
+		return h.runWindows(args)
+	}
+
+	bin, err := h.findUnixBinary()
 	if err != nil {
 		return err
 	}
@@ -82,21 +95,21 @@ func (h *Hermes) Run(_ string, args []string) error {
 }
 
 func (h *Hermes) Paths() []string {
-	configPath, err := hermesConfigPath()
+	backend, err := h.configBackend()
 	if err != nil {
 		return nil
 	}
-	return []string{configPath}
+	return []string{backend.displayPath}
 }
 
 func (h *Hermes) Configure(model string) error {
-	configPath, err := hermesConfigPath()
+	backend, err := h.configBackend()
 	if err != nil {
 		return err
 	}
 
 	cfg := map[string]any{}
-	if data, err := os.ReadFile(configPath); err == nil {
+	if data, err := backend.read(); err == nil {
 		if err := yaml.Unmarshal(data, &cfg); err != nil {
 			return fmt.Errorf("parse hermes config: %w", err)
 		}
@@ -129,18 +142,15 @@ func (h *Hermes) Configure(model string) error {
 	if err != nil {
 		return err
 	}
-	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-		return err
-	}
-	return fileutil.WriteWithBackup(configPath, data)
+	return backend.write(data)
 }
 
 func (h *Hermes) CurrentModel() string {
-	configPath, err := hermesConfigPath()
+	backend, err := h.configBackend()
 	if err != nil {
 		return ""
 	}
-	data, err := os.ReadFile(configPath)
+	data, err := backend.read()
 	if err != nil {
 		return ""
 	}
@@ -178,7 +188,14 @@ func (h *Hermes) RefreshRuntimeAfterConfigure() error {
 }
 
 func (h *Hermes) installed() bool {
-	_, err := h.binary()
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			return true
+		}
+		return h.wslHasHermes()
+	}
+
+	_, err := h.findUnixBinary()
 	return err == nil
 }
 
@@ -188,7 +205,7 @@ func (h *Hermes) ensureInstalled() error {
 	}
 
 	if hermesGOOS == "windows" {
-		return hermesWindowsHint()
+		return h.ensureInstalledWindows()
 	}
 
 	var missing []string
@@ -222,6 +239,42 @@ func (h *Hermes) ensureInstalled() error {
 	return nil
 }
 
+func (h *Hermes) ensureInstalledWindows() error {
+	// Hermes upstream support is WSL-oriented, so Windows launch uses a hybrid
+	// WSL handoff that stays on the same install path as upstream Hermes.
+	if _, err := hermesLookPath("hermes"); err == nil {
+		return nil
+	}
+	if !h.wslAvailable() {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+	if h.wslHasHermes() {
+		return nil
+	}
+
+	ok, err := ConfirmPromptWithOptions("Hermes runs through WSL2 on Windows. Install it in WSL now?", ConfirmOptions{
+		YesLabel: "Use WSL",
+		NoLabel:  "Show manual steps",
+	})
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+
+	fmt.Fprintf(os.Stderr, "\nInstalling Hermes in WSL...\n")
+	if err := h.runWSL("bash", "-lc", hermesInstallScript); err != nil {
+		return hermesWindowsHint(fmt.Errorf("failed to install hermes in WSL: %w", err))
+	}
+	if !h.wslHasHermes() {
+		return hermesWindowsHint(fmt.Errorf("hermes install finished but the WSL binary was not found"))
+	}
+
+	fmt.Fprintf(os.Stderr, "%sHermes installed successfully in WSL%s\n\n", ansiGreen, ansiReset)
+	return nil
+}
+
 func (h *Hermes) listModels(defaultModel string) []string {
 	client := hermesOllamaClient()
 	resp, err := client.List(context.Background())
@@ -253,15 +306,11 @@ func (h *Hermes) listModels(defaultModel string) []string {
 	return models
 }
 
-func (h *Hermes) binary() (string, error) {
+func (h *Hermes) findUnixBinary() (string, error) {
 	if path, err := hermesLookPath("hermes"); err == nil {
 		return path, nil
 	}
 
-	if hermesGOOS == "windows" {
-		return "", hermesWindowsHint()
-	}
-
 	home, err := hermesUserHome()
 	if err != nil {
 		return "", err
@@ -274,6 +323,70 @@ func (h *Hermes) binary() (string, error) {
 	return "", fmt.Errorf("hermes is not installed")
 }
 
+func (h *Hermes) runWindows(args []string) error {
+	if path, err := hermesLookPath("hermes"); err == nil {
+		if err := h.runGatewaySetupPreflight(args, func() error {
+			return hermesAttachedCommand(path, "gateway", "setup").Run()
+		}); err != nil {
+			return err
+		}
+		return hermesAttachedCommand(path, args...).Run()
+	}
+	if !h.wslAvailable() {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+	if err := h.runGatewaySetupPreflight(args, func() error {
+		return h.runWSL("hermes", "gateway", "setup")
+	}); err != nil {
+		return err
+	}
+	if err := h.runWSL(append([]string{"hermes"}, args...)...); err != nil {
+		return hermesWindowsHint(err)
+	}
+	return nil
+}
+
+func (h *Hermes) runWSL(args ...string) error {
+	if !h.wslAvailable() {
+		return fmt.Errorf("wsl.exe is not available")
+	}
+
+	return hermesAttachedCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).Run()
+}
+
+func (h *Hermes) runWSLCombinedOutput(args ...string) ([]byte, error) {
+	if !h.wslAvailable() {
+		return nil, fmt.Errorf("wsl.exe is not available")
+	}
+
+	return hermesCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).CombinedOutput()
+}
+
+func (h *Hermes) wslAvailable() bool {
+	_, err := hermesLookPath("wsl.exe")
+	return err == nil
+}
+
+func (h *Hermes) wslHasHermes() bool {
+	if !h.wslAvailable() {
+		return false
+	}
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", "command -v hermes >/dev/null 2>&1")
+	return cmd.Run() == nil
+}
+
+func (h *Hermes) configBackend() (*hermesConfigBackend, error) {
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			return hermesLocalConfigBackend()
+		}
+		if h.wslAvailable() {
+			return h.wslConfigBackend()
+		}
+	}
+	return hermesLocalConfigBackend()
+}
+
 func hermesConfigPath() (string, error) {
 	home, err := hermesUserHome()
 	if err != nil {
@@ -282,6 +395,110 @@ func hermesConfigPath() (string, error) {
 	return filepath.Join(home, ".hermes", "config.yaml"), nil
 }
 
+func hermesLocalConfigBackend() (*hermesConfigBackend, error) {
+	configPath, err := hermesConfigPath()
+	if err != nil {
+		return nil, err
+	}
+	return &hermesConfigBackend{
+		displayPath: configPath,
+		read: func() ([]byte, error) {
+			return os.ReadFile(configPath)
+		},
+		write: func(data []byte) error {
+			if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+				return err
+			}
+			return fileutil.WriteWithBackup(configPath, data)
+		},
+	}, nil
+}
+
+func (h *Hermes) wslConfigBackend() (*hermesConfigBackend, error) {
+	home, err := h.wslHome()
+	if err != nil {
+		return nil, err
+	}
+	configPath := pathpkg.Join(home, ".hermes", "config.yaml")
+	return &hermesConfigBackend{
+		displayPath: configPath,
+		read: func() ([]byte, error) {
+			return h.readWSLFile(configPath)
+		},
+		write: func(data []byte) error {
+			return h.writeWSLConfig(configPath, data)
+		},
+	}, nil
+}
+
+func (h *Hermes) wslHome() (string, error) {
+	if !h.wslAvailable() {
+		return "", fmt.Errorf("wsl.exe is not available")
+	}
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", `printf %s "$HOME"`)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	home := strings.TrimSpace(string(out))
+	if home == "" {
+		return "", fmt.Errorf("could not resolve WSL home directory")
+	}
+	return home, nil
+}
+
+func (h *Hermes) readWSLFile(path string) ([]byte, error) {
+	pathArg := shellQuoteArgs([]string{path})
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", fmt.Sprintf("if [ -f %s ]; then cat %s; else exit 42; fi", pathArg, pathArg))
+	out, err := cmd.Output()
+	if err == nil {
+		return out, nil
+	}
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) && exitErr.ExitCode() == 42 {
+		return nil, os.ErrNotExist
+	}
+	return nil, err
+}
+
+func (h *Hermes) writeWSLConfig(path string, data []byte) error {
+	if existing, err := h.readWSLFile(path); err == nil {
+		if !bytes.Equal(existing, data) {
+			if err := hermesBackupData(path, existing); err != nil {
+				return fmt.Errorf("backup failed: %w", err)
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("read existing file: %w", err)
+	}
+
+	dir := pathpkg.Dir(path)
+	dirArg := shellQuoteArgs([]string{dir})
+	pathArg := shellQuoteArgs([]string{path})
+	script := fmt.Sprintf(
+		"dir=%s; path=%s; mkdir -p \"$dir\" && tmp=$(mktemp \"$dir/.tmp-XXXXXX\") && cat > \"$tmp\" && mv \"$tmp\" \"$path\"",
+		dirArg,
+		pathArg,
+	)
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", script)
+	cmd.Stdin = bytes.NewReader(data)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		if msg := strings.TrimSpace(string(out)); msg != "" {
+			return fmt.Errorf("%w: %s", err, msg)
+		}
+		return err
+	}
+	return nil
+}
+
+func hermesBackupData(path string, data []byte) error {
+	if err := os.MkdirAll(fileutil.BackupDir(), 0o755); err != nil {
+		return err
+	}
+	backupPath := filepath.Join(fileutil.BackupDir(), fmt.Sprintf("%s.%d", filepath.Base(path), time.Now().Unix()))
+	return os.WriteFile(backupPath, data, 0o644)
+}
+
 func hermesBaseURL() string {
 	return strings.TrimRight(hermesOllamaURL().String(), "/") + "/v1"
 }
@@ -337,11 +554,8 @@ func (h *Hermes) messagingConfigured() bool {
 func (h *Hermes) gatewayEnvVars() (map[string]string, error) {
 	envVars := make(map[string]string)
 
-	envFilePath, err := hermesEnvPath()
-	if err != nil {
-		return nil, err
-	}
-	switch data, err := os.ReadFile(envFilePath); {
+	data, err := h.readGatewayEnvFile()
+	switch {
 	case err == nil:
 		for key, value := range hermesParseEnvFile(data) {
 			envVars[key] = value
@@ -352,10 +566,12 @@ func (h *Hermes) gatewayEnvVars() (map[string]string, error) {
 		return nil, err
 	}
 
-	for _, group := range hermesMessagingEnvGroups {
-		for _, key := range group {
-			if value, ok := os.LookupEnv(key); ok {
-				envVars[key] = value
+	if h.usesLocalRuntimeEnv() {
+		for _, group := range hermesMessagingEnvGroups {
+			for _, key := range group {
+				if value, ok := os.LookupEnv(key); ok {
+					envVars[key] = value
+				}
 			}
 		}
 	}
@@ -363,6 +579,39 @@ func (h *Hermes) gatewayEnvVars() (map[string]string, error) {
 	return envVars, nil
 }
 
+func (h *Hermes) readGatewayEnvFile() ([]byte, error) {
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			path, err := hermesEnvPath()
+			if err != nil {
+				return nil, err
+			}
+			return os.ReadFile(path)
+		}
+		if h.wslAvailable() {
+			home, err := h.wslHome()
+			if err != nil {
+				return nil, err
+			}
+			return h.readWSLFile(pathpkg.Join(home, ".hermes", ".env"))
+		}
+	}
+
+	path, err := hermesEnvPath()
+	if err != nil {
+		return nil, err
+	}
+	return os.ReadFile(path)
+}
+
+func (h *Hermes) usesLocalRuntimeEnv() bool {
+	if hermesGOOS != "windows" {
+		return true
+	}
+	_, err := hermesLookPath("hermes")
+	return err == nil
+}
+
 func (h *Hermes) gatewayRunning() (bool, error) {
 	status, err := h.gatewayStatusOutput()
 	if err != nil {
@@ -372,7 +621,19 @@ func (h *Hermes) gatewayRunning() (bool, error) {
 }
 
 func (h *Hermes) gatewayStatusOutput() (string, error) {
-	bin, err := h.binary()
+	if hermesGOOS == "windows" {
+		if path, err := hermesLookPath("hermes"); err == nil {
+			out, err := hermesCommand(path, "gateway", "status").CombinedOutput()
+			return string(out), err
+		}
+		if !h.wslAvailable() {
+			return "", hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+		}
+		out, err := h.runWSLCombinedOutput("hermes", "gateway", "status")
+		return string(out), err
+	}
+
+	bin, err := h.findUnixBinary()
 	if err != nil {
 		return "", err
 	}
@@ -381,7 +642,20 @@ func (h *Hermes) gatewayStatusOutput() (string, error) {
 }
 
 func (h *Hermes) restartGateway() error {
-	bin, err := h.binary()
+	if hermesGOOS == "windows" {
+		if path, err := hermesLookPath("hermes"); err == nil {
+			return hermesAttachedCommand(path, "gateway", "restart").Run()
+		}
+		if !h.wslAvailable() {
+			return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+		}
+		if err := h.runWSL("hermes", "gateway", "restart"); err != nil {
+			return hermesWindowsHint(err)
+		}
+		return nil
+	}
+
+	bin, err := h.findUnixBinary()
 	if err != nil {
 		return err
 	}
@@ -664,6 +938,14 @@ func mergeHermesToolsets(current any) any {
 	}
 }
 
+func shellQuoteArgs(args []string) string {
+	quoted := make([]string, 0, len(args))
+	for _, arg := range args {
+		quoted = append(quoted, "'"+strings.ReplaceAll(arg, "'", `'\''`)+"'")
+	}
+	return strings.Join(quoted, " ")
+}
+
 func hermesAttachedCommand(name string, args ...string) *exec.Cmd {
 	cmd := hermesCommand(name, args...)
 	cmd.Stdin = os.Stdin
@@ -672,8 +954,9 @@ func hermesAttachedCommand(name string, args ...string) *exec.Cmd {
 	return cmd
 }
 
-func hermesWindowsHint() error {
-	return fmt.Errorf("Hermes on Windows requires WSL2. Install WSL with: wsl --install\n" +
-		"Then run 'ollama launch hermes' from inside your WSL shell.\n" +
-		"Docs: https://hermes-agent.nousresearch.com/docs/getting-started/installation/")
+func hermesWindowsHint(err error) error {
+	if hermesGOOS != "windows" {
+		return err
+	}
+	return fmt.Errorf("%w\n\nHermes runs on Windows through WSL2.\nQuick setup: wsl --install\nInstaller docs: https://hermes-agent.nousresearch.com/docs/getting-started/installation/", err)
 }

cmd/launch/hermes_test.go

@@ -896,6 +896,64 @@ fi
 	}
 }
 
+func TestHermesRefreshRuntimeAfterConfigure_WindowsWSLRestartsRunningGateway(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("uses POSIX shell test binaries to simulate WSL")
+	}
+
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withHermesPlatform(t, "windows")
+	t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+	wslPath := filepath.Join(tmpDir, "wsl.exe")
+	wslScript := `#!/bin/sh
+printf '[%s]\n' "$*" >> "$HOME/wsl-invocations.log"
+exec /bin/sh -lc "$3"
+`
+	if err := os.WriteFile(wslPath, []byte(wslScript), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	hermesBin := filepath.Join(tmpDir, "hermes")
+	hermesScript := `#!/bin/sh
+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"
+if [ "$1" = "gateway" ] && [ "$2" = "status" ]; then
+  printf '✓ Gateway is running (PID: 321)\n'
+fi
+`
+	if err := os.WriteFile(hermesBin, []byte(hermesScript), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	withHermesLookPath(t, func(file string) (string, error) {
+		if file == "wsl.exe" {
+			return wslPath, nil
+		}
+		return "", os.ErrNotExist
+	})
+
+	h := &Hermes{}
+	if err := h.RefreshRuntimeAfterConfigure(); err != nil {
+		t.Fatalf("RefreshRuntimeAfterConfigure returned error: %v", err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
+	if len(lines) != 2 {
+		t.Fatalf("expected WSL status then restart invocations, got %v", lines)
+	}
+	if lines[0] != "[gateway status]" {
+		t.Fatalf("expected WSL gateway status first, got %q", lines[0])
+	}
+	if lines[1] != "[gateway restart]" {
+		t.Fatalf("expected WSL gateway restart second, got %q", lines[1])
+	}
+}
+
 func TestHermesMessagingConfiguredRecognizesSupportedGatewayVars(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
@@ -944,7 +1002,82 @@ func TestHermesMessagingConfiguredRecognizesSupportedGatewayVars(t *testing.T) {
 	}
 }
 
-func TestHermesEnsureInstalledWindowsShowsWSLGuidance(t *testing.T) {
+func TestHermesRunWindowsWSL_UsesGatewaySetupPreflight(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("uses POSIX shell test binaries to simulate WSL")
+	}
+
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+	withLauncherHooks(t)
+	withInteractiveSession(t, true)
+	withHermesPlatform(t, "windows")
+	clearHermesMessagingEnvVars(t)
+	t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+	wslPath := filepath.Join(tmpDir, "wsl.exe")
+	wslScript := `#!/bin/sh
+printf '[%s]\n' "$*" >> "$HOME/wsl-invocations.log"
+exec /bin/sh -lc "$3"
+`
+	if err := os.WriteFile(wslPath, []byte(wslScript), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	hermesBin := filepath.Join(tmpDir, "hermes")
+	hermesScript := `#!/bin/sh
+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"
+if [ "$1" = "gateway" ] && [ "$2" = "setup" ]; then
+  /bin/mkdir -p "$HOME/.hermes"
+  printf 'TELEGRAM_BOT_TOKEN=configured\n' > "$HOME/.hermes/.env"
+fi
+`
+	if err := os.WriteFile(hermesBin, []byte(hermesScript), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	withHermesLookPath(t, func(file string) (string, error) {
+		if file == "wsl.exe" {
+			return wslPath, nil
+		}
+		return "", os.ErrNotExist
+	})
+
+	promptCount := 0
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		promptCount++
+		if prompt != hermesGatewaySetupTitle {
+			t.Fatalf("unexpected prompt %q", prompt)
+		}
+		return true, nil
+	}
+
+	h := &Hermes{}
+	if err := h.Run("", nil); err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+
+	if promptCount != 1 {
+		t.Fatalf("expected one messaging prompt, got %d", promptCount)
+	}
+
+	data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
+	if len(lines) != 2 {
+		t.Fatalf("expected WSL hermes to run setup then launch, got %v", lines)
+	}
+	if lines[0] != "[gateway setup]" {
+		t.Fatalf("expected WSL gateway setup first, got %q", lines[0])
+	}
+	if lines[1] != "[]" {
+		t.Fatalf("expected WSL default hermes launch second, got %q", lines[1])
+	}
+}
+
+func TestHermesEnsureInstalledWindowsWithoutWSLGivesGuidance(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
 	withHermesPlatform(t, "windows")
@@ -953,17 +1086,10 @@ func TestHermesEnsureInstalledWindowsShowsWSLGuidance(t *testing.T) {
 	h := &Hermes{}
 	err := h.ensureInstalled()
 	if err == nil {
-		t.Fatal("expected WSL guidance error")
+		t.Fatal("expected missing WSL guidance error")
 	}
-	msg := err.Error()
-	if !strings.Contains(msg, "wsl --install") {
-		t.Fatalf("expected install command in guidance, got %v", err)
-	}
-	if !strings.Contains(msg, "hermes-agent.nousresearch.com") {
-		t.Fatalf("expected docs link in guidance, got %v", err)
-	}
-	if strings.Contains(msg, "hermes is not installed") {
-		t.Fatalf("guidance should not lead with 'hermes is not installed', got %v", err)
+	if !strings.Contains(err.Error(), "wsl --install") {
+		t.Fatalf("expected WSL guidance, got %v", err)
 	}
 }
 

cmd/launch/integrations_test.go

@@ -54,7 +54,6 @@ func TestIntegrationLookup(t *testing.T) {
 		{"claude uppercase", "CLAUDE", true, "Claude Code"},
 		{"claude mixed case", "Claude", true, "Claude Code"},
 		{"codex", "codex", true, "Codex"},
-		{"kimi", "kimi", true, "Kimi Code CLI"},
 		{"droid", "droid", true, "Droid"},
 		{"opencode", "opencode", true, "OpenCode"},
 		{"unknown integration", "unknown", false, ""},
@@ -75,7 +74,7 @@ func TestIntegrationLookup(t *testing.T) {
 }
 
 func TestIntegrationRegistry(t *testing.T) {
-	expectedIntegrations := []string{"claude", "codex", "kimi", "droid", "opencode", "hermes"}
+	expectedIntegrations := []string{"claude", "codex", "droid", "opencode", "hermes"}
 
 	for _, name := range expectedIntegrations {
 		t.Run(name, func(t *testing.T) {
@@ -90,15 +89,6 @@ func TestIntegrationRegistry(t *testing.T) {
 	}
 }
 
-func TestHiddenIntegrationsExcludedFromVisibleLists(t *testing.T) {
-	for _, info := range ListIntegrationInfos() {
-		switch info.Name {
-		case "cline", "vscode", "kimi":
-			t.Fatalf("hidden integration %q should not appear in ListIntegrationInfos", info.Name)
-		}
-	}
-}
-
 func TestHasLocalModel(t *testing.T) {
 	tests := []struct {
 		name   string
@@ -301,7 +291,7 @@ func TestParseArgs(t *testing.T) {
 func TestIsCloudModel(t *testing.T) {
 	// isCloudModel now only uses Show API, so nil client always returns false
 	t.Run("nil client returns false", func(t *testing.T) {
-		models := []string{"glm-5.1:cloud", "kimi-k2.6:cloud", "local-model"}
+		models := []string{"glm-5.1:cloud", "kimi-k2.5:cloud", "local-model"}
 		for _, model := range models {
 			if isCloudModel(context.Background(), nil, model) {
 				t.Errorf("isCloudModel(%q) with nil client should return false", model)
@@ -318,18 +308,10 @@ func names(items []ModelItem) []string {
 	return out
 }
 
-func recommendedNames(extra ...string) []string {
-	out := make([]string, 0, len(recommendedModels)+len(extra))
-	for _, item := range recommendedModels {
-		out = append(out, item.Name)
-	}
-	return append(out, extra...)
-}
-
 func TestBuildModelList_NoExistingModels(t *testing.T) {
 	items, _, _, _ := buildModelList(nil, nil, "")
 
-	want := recommendedNames()
+	want := []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud", "gemma4", "qwen3.5"}
 	if diff := cmp.Diff(want, names(items)); diff != "" {
 		t.Errorf("with no existing models, items should be recommended in order (-want +got):\n%s", diff)
 	}
@@ -358,7 +340,7 @@ func TestBuildModelList_OnlyLocalModels_CloudRecsStillFirst(t *testing.T) {
 
 	// Cloud recs always come first among recommended, regardless of installed inventory.
 	// Cloud disablement is handled upstream in loadSelectableModels via filterCloudItems.
-	want := recommendedNames("llama3.2", "qwen2.5")
+	want := []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud", "gemma4", "qwen3.5", "llama3.2", "qwen2.5"}
 	if diff := cmp.Diff(want, got); diff != "" {
 		t.Errorf("cloud recs pinned first even when no cloud models installed (-want +got):\n%s", diff)
 	}
@@ -374,13 +356,13 @@ func TestBuildModelList_BothCloudAndLocal_RegularSort(t *testing.T) {
 	got := names(items)
 
 	// All recs pinned at top (cloud before local in mixed case), then non-recs
-	want := recommendedNames("llama3.2")
+	want := []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud", "gemma4", "qwen3.5", "llama3.2"}
 	if diff := cmp.Diff(want, got); diff != "" {
 		t.Errorf("recs pinned at top, cloud recs first in mixed case (-want +got):\n%s", diff)
 	}
 }
 
-func TestBuildModelList_PreCheckedNonRecommendedFirstInMore(t *testing.T) {
+func TestBuildModelList_PreCheckedFirst(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
 		{Name: "glm-5.1:cloud", Remote: true},
@@ -389,9 +371,8 @@ func TestBuildModelList_PreCheckedNonRecommendedFirstInMore(t *testing.T) {
 	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
 	got := names(items)
 
-	want := recommendedNames("llama3.2")
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recommended block should stay fixed while checked non-recommended models lead More (-want +got):\n%s", diff)
+	if got[0] != "llama3.2" {
+		t.Errorf("pre-checked model should be first, got %v", got)
 	}
 }
 
@@ -446,7 +427,7 @@ func TestBuildModelList_ExistingRecommendedMarked(t *testing.T) {
 			if !strings.HasSuffix(item.Description, "(not downloaded)") {
 				t.Errorf("non-installed recommended %q should have '(not downloaded)' suffix, got %q", item.Name, item.Description)
 			}
-		case "minimax-m2.7:cloud", "kimi-k2.6:cloud", "qwen3.5:cloud":
+		case "minimax-m2.7:cloud", "kimi-k2.5:cloud", "qwen3.5:cloud":
 			if strings.HasSuffix(item.Description, "(not downloaded)") {
 				t.Errorf("cloud model %q should not have '(not downloaded)' suffix, got %q", item.Name, item.Description)
 			}
@@ -464,9 +445,9 @@ func TestBuildModelList_ExistingCloudModelsNotPushedToBottom(t *testing.T) {
 	got := names(items)
 
 	// gemma4 and glm-5.1:cloud are installed so they sort normally;
-	// qwen3.5:cloud and qwen3.5 are not installed so they go to the bottom
+	// kimi-k2.5:cloud, qwen3.5:cloud, and qwen3.5 are not installed so they go to the bottom
 	// All recs: cloud first in mixed case, then local, in rec order within each
-	want := recommendedNames()
+	want := []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud", "gemma4", "qwen3.5"}
 	if diff := cmp.Diff(want, got); diff != "" {
 		t.Errorf("all recs, cloud first in mixed case (-want +got):\n%s", diff)
 	}
@@ -475,23 +456,23 @@ func TestBuildModelList_ExistingCloudModelsNotPushedToBottom(t *testing.T) {
 func TestBuildModelList_HasRecommendedCloudModel_OnlyNonInstalledAtBottom(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
-		{Name: "kimi-k2.6:cloud", Remote: true},
+		{Name: "kimi-k2.5:cloud", Remote: true},
 	}
 
 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)
 
-	// kimi-k2.6:cloud is installed so it sorts normally;
+	// kimi-k2.5:cloud is installed so it sorts normally;
 	// the rest of the recommendations are not installed so they go to the bottom
 	// All recs pinned at top (cloud first in mixed case), then non-recs
-	want := recommendedNames("llama3.2")
+	want := []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud", "gemma4", "qwen3.5", "llama3.2"}
 	if diff := cmp.Diff(want, got); diff != "" {
 		t.Errorf("recs pinned at top, cloud first in mixed case (-want +got):\n%s", diff)
 	}
 
 	for _, item := range items {
 		isCloud := strings.HasSuffix(item.Name, ":cloud")
-		isInstalled := slices.Contains([]string{"kimi-k2.6:cloud", "llama3.2"}, item.Name)
+		isInstalled := slices.Contains([]string{"kimi-k2.5:cloud", "llama3.2"}, item.Name)
 		if isInstalled || isCloud {
 			if strings.HasSuffix(item.Description, "(not downloaded)") {
 				t.Errorf("installed or cloud model %q should not have '(not downloaded)' suffix, got %q", item.Name, item.Description)
@@ -558,8 +539,8 @@ func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
 	if !cloudModels["glm-5.1:cloud"] {
 		t.Error("glm-5.1:cloud should be in cloudModels")
 	}
-	if !cloudModels["kimi-k2.6:cloud"] {
-		t.Error("kimi-k2.6:cloud should be in cloudModels (recommended cloud)")
+	if !cloudModels["kimi-k2.5:cloud"] {
+		t.Error("kimi-k2.5:cloud should be in cloudModels (recommended cloud)")
 	}
 	if !cloudModels["qwen3.5:cloud"] {
 		t.Error("qwen3.5:cloud should be in cloudModels (recommended cloud)")
@@ -579,7 +560,7 @@ func TestBuildModelList_RecommendedFieldSet(t *testing.T) {
 
 	for _, item := range items {
 		switch item.Name {
-		case "gemma4", "qwen3.5", "glm-5.1:cloud", "kimi-k2.6:cloud", "qwen3.5:cloud":
+		case "gemma4", "qwen3.5", "glm-5.1:cloud", "kimi-k2.5:cloud", "qwen3.5:cloud":
 			if !item.Recommended {
 				t.Errorf("%q should have Recommended=true", item.Name)
 			}
@@ -637,7 +618,7 @@ func TestBuildModelList_RecsAboveNonRecs(t *testing.T) {
 	lastRecIdx := -1
 	firstNonRecIdx := len(got)
 	for i, name := range got {
-		isRec := name == "gemma4" || name == "qwen3.5" || name == "minimax-m2.7:cloud" || name == "glm-5.1:cloud" || name == "kimi-k2.6:cloud" || name == "qwen3.5:cloud"
+		isRec := name == "gemma4" || name == "qwen3.5" || name == "minimax-m2.7:cloud" || name == "glm-5.1:cloud" || name == "kimi-k2.5:cloud" || name == "qwen3.5:cloud"
 		if isRec && i > lastRecIdx {
 			lastRecIdx = i
 		}
@@ -650,32 +631,17 @@ func TestBuildModelList_RecsAboveNonRecs(t *testing.T) {
 	}
 }
 
-func TestBuildModelList_CheckedRecommendedDoesNotReshuffleRecommendedOrder(t *testing.T) {
+func TestBuildModelList_CheckedBeforeRecs(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
 		{Name: "glm-5.1:cloud", Remote: true},
 	}
 
-	items, _, _, _ := buildModelList(existing, []string{"qwen3.5:cloud", "glm-5.1:cloud"}, "")
+	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
 	got := names(items)
 
-	want := recommendedNames("llama3.2")
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("checked recommended models should not reshuffle the fixed recommended order (-want +got):\n%s", diff)
-	}
-}
-
-func TestBuildModelList_StaleSavedKimiK25DoesNotReshuffleRecommendedOrder(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "kimi-k2.5:cloud", Remote: true},
-	}
-
-	items, _, _, _ := buildModelList(existing, []string{"kimi-k2.5:cloud", "qwen3.5:cloud", "glm-5.1:cloud", "minimax-m2.7:cloud"}, "kimi-k2.5:cloud")
-	got := names(items)
-
-	want := recommendedNames("kimi-k2.5:cloud")
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("stale saved kimi-k2.5 should stay in More without reshuffling the fixed recommended order (-want +got):\n%s", diff)
+	if got[0] != "llama3.2" {
+		t.Errorf("checked model should be first even before recs, got %v", got)
 	}
 }
 

cmd/launch/kimi.go

@@ -1,315 +0,0 @@
-package launch
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/envconfig"
-)
-
-// Kimi implements Runner for Kimi Code CLI integration.
-type Kimi struct{}
-
-const (
-	kimiDefaultModelAlias     = "ollama"
-	kimiDefaultMaxContextSize = 32768
-)
-
-var (
-	kimiGOOS             = runtime.GOOS
-	kimiModelShowTimeout = 5 * time.Second
-)
-
-func (k *Kimi) String() string { return "Kimi Code CLI" }
-
-func (k *Kimi) args(config string, extra []string) []string {
-	args := []string{"--config", config}
-	args = append(args, extra...)
-	return args
-}
-
-func (k *Kimi) Run(model string, args []string) error {
-	if strings.TrimSpace(model) == "" {
-		return fmt.Errorf("model is required")
-	}
-	if err := validateKimiPassthroughArgs(args); err != nil {
-		return err
-	}
-
-	config, err := buildKimiInlineConfig(model, resolveKimiMaxContextSize(model))
-	if err != nil {
-		return fmt.Errorf("failed to build kimi config: %w", err)
-	}
-
-	bin, err := ensureKimiInstalled()
-	if err != nil {
-		return err
-	}
-
-	cmd := exec.Command(bin, k.args(config, args)...)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
-
-func findKimiBinary() (string, error) {
-	if path, err := exec.LookPath("kimi"); err == nil {
-		return path, nil
-	}
-
-	home, _ := os.UserHomeDir()
-
-	var candidates []string
-	switch kimiGOOS {
-	case "windows":
-		candidates = appendWindowsKimiCandidates(candidates, filepath.Join(home, ".local", "bin"))
-		candidates = appendWindowsKimiCandidates(candidates, filepath.Join(home, "bin"))
-
-		if appData := strings.TrimSpace(os.Getenv("APPDATA")); appData != "" {
-			candidates = appendWindowsKimiCandidates(candidates, filepath.Join(appData, "uv", "bin"))
-		}
-		if localAppData := strings.TrimSpace(os.Getenv("LOCALAPPDATA")); localAppData != "" {
-			candidates = appendWindowsKimiCandidates(candidates, filepath.Join(localAppData, "uv", "bin"))
-		}
-	default:
-		candidates = append(candidates,
-			filepath.Join(home, ".local", "bin", "kimi"),
-			filepath.Join(home, "bin", "kimi"),
-			filepath.Join(home, ".local", "share", "uv", "tools", "kimi-cli", "bin", "kimi"),
-			filepath.Join(home, ".local", "share", "uv", "tools", "kimi", "bin", "kimi"),
-		)
-
-		if xdgDataHome := strings.TrimSpace(os.Getenv("XDG_DATA_HOME")); xdgDataHome != "" {
-			candidates = append(candidates,
-				filepath.Join(xdgDataHome, "uv", "tools", "kimi-cli", "bin", "kimi"),
-				filepath.Join(xdgDataHome, "uv", "tools", "kimi", "bin", "kimi"),
-			)
-		}
-
-		// WSL users can inherit Windows env vars while launching from Linux shells.
-		if profile := windowsPathToWSL(os.Getenv("USERPROFILE")); profile != "" {
-			candidates = appendWindowsKimiCandidates(candidates, filepath.Join(profile, ".local", "bin"))
-		}
-		if appData := windowsPathToWSL(os.Getenv("APPDATA")); appData != "" {
-			candidates = appendWindowsKimiCandidates(candidates, filepath.Join(appData, "uv", "bin"))
-		}
-		if localAppData := windowsPathToWSL(os.Getenv("LOCALAPPDATA")); localAppData != "" {
-			candidates = appendWindowsKimiCandidates(candidates, filepath.Join(localAppData, "uv", "bin"))
-		}
-	}
-
-	for _, candidate := range candidates {
-		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
-			return candidate, nil
-		}
-	}
-
-	return "", fmt.Errorf("kimi binary not found")
-}
-
-func appendWindowsKimiCandidates(candidates []string, dir string) []string {
-	if strings.TrimSpace(dir) == "" {
-		return candidates
-	}
-
-	return append(candidates,
-		filepath.Join(dir, "kimi.exe"),
-		filepath.Join(dir, "kimi.cmd"),
-		filepath.Join(dir, "kimi.bat"),
-	)
-}
-
-func windowsPathToWSL(path string) string {
-	trimmed := strings.TrimSpace(path)
-	if len(trimmed) < 3 || trimmed[1] != ':' {
-		return ""
-	}
-
-	drive := strings.ToLower(string(trimmed[0]))
-	rest := strings.ReplaceAll(trimmed[2:], "\\", "/")
-	rest = strings.TrimPrefix(rest, "/")
-	if rest == "" {
-		return filepath.Join("/mnt", drive)
-	}
-
-	return filepath.Join("/mnt", drive, rest)
-}
-
-func validateKimiPassthroughArgs(args []string) error {
-	for _, arg := range args {
-		switch {
-		case arg == "--config", strings.HasPrefix(arg, "--config="):
-			return fmt.Errorf("conflicting extra argument %q: ollama launch kimi manages --config", arg)
-		case arg == "--config-file", strings.HasPrefix(arg, "--config-file="):
-			return fmt.Errorf("conflicting extra argument %q: ollama launch kimi manages --config-file", arg)
-		case arg == "--model", strings.HasPrefix(arg, "--model="):
-			return fmt.Errorf("conflicting extra argument %q: ollama launch kimi manages --model", arg)
-		case arg == "-m", strings.HasPrefix(arg, "-m="):
-			return fmt.Errorf("conflicting extra argument %q: ollama launch kimi manages -m/--model", arg)
-		}
-	}
-	return nil
-}
-
-func buildKimiInlineConfig(model string, maxContextSize int) (string, error) {
-	cfg := map[string]any{
-		"default_model": kimiDefaultModelAlias,
-		"providers": map[string]any{
-			kimiDefaultModelAlias: map[string]any{
-				"type":     "openai_legacy",
-				"base_url": envconfig.ConnectableHost().String() + "/v1",
-				"api_key":  "ollama",
-			},
-		},
-		"models": map[string]any{
-			kimiDefaultModelAlias: map[string]any{
-				"provider":         kimiDefaultModelAlias,
-				"model":            model,
-				"max_context_size": maxContextSize,
-			},
-		},
-	}
-
-	data, err := json.Marshal(cfg)
-	if err != nil {
-		return "", err
-	}
-	return string(data), nil
-}
-
-func resolveKimiMaxContextSize(model string) int {
-	if l, ok := lookupCloudModelLimit(model); ok {
-		return l.Context
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return kimiDefaultMaxContextSize
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), kimiModelShowTimeout)
-	defer cancel()
-	resp, err := client.Show(ctx, &api.ShowRequest{Model: model})
-	if err != nil {
-		return kimiDefaultMaxContextSize
-	}
-
-	if n, ok := modelInfoContextLength(resp.ModelInfo); ok {
-		return n
-	}
-
-	return kimiDefaultMaxContextSize
-}
-
-func modelInfoContextLength(modelInfo map[string]any) (int, bool) {
-	for key, val := range modelInfo {
-		if !strings.HasSuffix(key, ".context_length") {
-			continue
-		}
-		switch v := val.(type) {
-		case float64:
-			if v > 0 {
-				return int(v), true
-			}
-		case int:
-			if v > 0 {
-				return v, true
-			}
-		case int64:
-			if v > 0 {
-				return int(v), true
-			}
-		}
-	}
-	return 0, false
-}
-
-func ensureKimiInstalled() (string, error) {
-	if path, err := findKimiBinary(); err == nil {
-		return path, nil
-	}
-
-	if err := checkKimiInstallerDependencies(); err != nil {
-		return "", err
-	}
-
-	ok, err := ConfirmPrompt("Kimi is not installed. Install now?")
-	if err != nil {
-		return "", err
-	}
-	if !ok {
-		return "", fmt.Errorf("kimi installation cancelled")
-	}
-
-	bin, args, err := kimiInstallerCommand(kimiGOOS)
-	if err != nil {
-		return "", err
-	}
-
-	fmt.Fprintf(os.Stderr, "\nInstalling Kimi...\n")
-	cmd := exec.Command(bin, args...)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return "", fmt.Errorf("failed to install kimi: %w", err)
-	}
-
-	path, err := findKimiBinary()
-	if err != nil {
-		return "", fmt.Errorf("kimi was installed but the binary was not found on PATH\n\nYou may need to restart your shell")
-	}
-
-	fmt.Fprintf(os.Stderr, "%sKimi installed successfully%s\n\n", ansiGreen, ansiReset)
-	return path, nil
-}
-
-func checkKimiInstallerDependencies() error {
-	switch kimiGOOS {
-	case "windows":
-		if _, err := exec.LookPath("powershell"); err != nil {
-			return fmt.Errorf("kimi is not installed and required dependencies are missing\n\nInstall the following first:\n  PowerShell: https://learn.microsoft.com/powershell/\n\nThen re-run:\n  ollama launch kimi")
-		}
-	default:
-		var missing []string
-		if _, err := exec.LookPath("curl"); err != nil {
-			missing = append(missing, "curl: https://curl.se/")
-		}
-		if _, err := exec.LookPath("bash"); err != nil {
-			missing = append(missing, "bash: https://www.gnu.org/software/bash/")
-		}
-		if len(missing) > 0 {
-			return fmt.Errorf("kimi is not installed and required dependencies are missing\n\nInstall the following first:\n  %s\n\nThen re-run:\n  ollama launch kimi", strings.Join(missing, "\n  "))
-		}
-	}
-	return nil
-}
-
-func kimiInstallerCommand(goos string) (string, []string, error) {
-	switch goos {
-	case "windows":
-		return "powershell", []string{
-			"-NoProfile",
-			"-ExecutionPolicy",
-			"Bypass",
-			"-Command",
-			"Invoke-RestMethod https://code.kimi.com/install.ps1 | Invoke-Expression",
-		}, nil
-	case "darwin", "linux":
-		return "bash", []string{
-			"-c",
-			"curl -LsSf https://code.kimi.com/install.sh | bash",
-		}, nil
-	default:
-		return "", nil, fmt.Errorf("unsupported platform for kimi install: %s", goos)
-	}
-}

cmd/launch/kimi_test.go

@@ -1,636 +0,0 @@
-package launch
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"runtime"
-	"slices"
-	"strings"
-	"testing"
-)
-
-func assertKimiBinPath(t *testing.T, bin string) {
-	t.Helper()
-	base := strings.ToLower(filepath.Base(bin))
-	if !strings.HasPrefix(base, "kimi") {
-		t.Fatalf("bin = %q, want path to kimi executable", bin)
-	}
-}
-
-func TestKimiIntegration(t *testing.T) {
-	k := &Kimi{}
-
-	t.Run("String", func(t *testing.T) {
-		if got := k.String(); got != "Kimi Code CLI" {
-			t.Errorf("String() = %q, want %q", got, "Kimi Code CLI")
-		}
-	})
-
-	t.Run("implements Runner", func(t *testing.T) {
-		var _ Runner = k
-	})
-}
-
-func TestKimiArgs(t *testing.T) {
-	k := &Kimi{}
-
-	got := k.args(`{"foo":"bar"}`, []string{"--quiet", "--print"})
-	want := []string{"--config", `{"foo":"bar"}`, "--quiet", "--print"}
-	if !slices.Equal(got, want) {
-		t.Fatalf("args() = %v, want %v", got, want)
-	}
-}
-
-func TestWindowsPathToWSL(t *testing.T) {
-	tests := []struct {
-		name  string
-		in    string
-		want  string
-		valid bool
-	}{
-		{
-			name:  "user profile path",
-			in:    `C:\Users\parth`,
-			want:  filepath.Join("/mnt", "c", "Users", "parth"),
-			valid: true,
-		},
-		{
-			name:  "path with trailing slash",
-			in:    `D:\tools\bin\`,
-			want:  filepath.Join("/mnt", "d", "tools", "bin"),
-			valid: true,
-		},
-		{
-			name:  "non windows path",
-			in:    "/home/parth",
-			valid: false,
-		},
-		{
-			name:  "empty",
-			in:    "",
-			valid: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := windowsPathToWSL(tt.in)
-			if !tt.valid {
-				if got != "" {
-					t.Fatalf("windowsPathToWSL(%q) = %q, want empty", tt.in, got)
-				}
-				return
-			}
-			if got != tt.want {
-				t.Fatalf("windowsPathToWSL(%q) = %q, want %q", tt.in, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestFindKimiBinaryFallbacks(t *testing.T) {
-	oldGOOS := kimiGOOS
-	t.Cleanup(func() { kimiGOOS = oldGOOS })
-
-	t.Run("linux/ubuntu uv tool path", func(t *testing.T) {
-		homeDir := t.TempDir()
-		setTestHome(t, homeDir)
-		t.Setenv("PATH", t.TempDir())
-		kimiGOOS = "linux"
-
-		target := filepath.Join(homeDir, ".local", "share", "uv", "tools", "kimi-cli", "bin", "kimi")
-		if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-			t.Fatalf("failed to create candidate dir: %v", err)
-		}
-		if err := os.WriteFile(target, []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
-			t.Fatalf("failed to write kimi candidate: %v", err)
-		}
-
-		got, err := findKimiBinary()
-		if err != nil {
-			t.Fatalf("findKimiBinary() error = %v", err)
-		}
-		if got != target {
-			t.Fatalf("findKimiBinary() = %q, want %q", got, target)
-		}
-	})
-
-	t.Run("windows appdata uv bin", func(t *testing.T) {
-		setTestHome(t, t.TempDir())
-		t.Setenv("PATH", t.TempDir())
-		kimiGOOS = "windows"
-
-		appDataDir := t.TempDir()
-		t.Setenv("APPDATA", appDataDir)
-		t.Setenv("LOCALAPPDATA", "")
-
-		target := filepath.Join(appDataDir, "uv", "bin", "kimi.cmd")
-		if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-			t.Fatalf("failed to create candidate dir: %v", err)
-		}
-		if err := os.WriteFile(target, []byte("@echo off\r\nexit /b 0\r\n"), 0o755); err != nil {
-			t.Fatalf("failed to write kimi candidate: %v", err)
-		}
-
-		got, err := findKimiBinary()
-		if err != nil {
-			t.Fatalf("findKimiBinary() error = %v", err)
-		}
-		if got != target {
-			t.Fatalf("findKimiBinary() = %q, want %q", got, target)
-		}
-	})
-}
-
-func TestValidateKimiPassthroughArgs_RejectsConflicts(t *testing.T) {
-	tests := []struct {
-		name string
-		args []string
-		want string
-	}{
-		{name: "--config", args: []string{"--config", "{}"}, want: "--config"},
-		{name: "--config=", args: []string{"--config={}"}, want: "--config={"},
-		{name: "--config-file", args: []string{"--config-file", "x.toml"}, want: "--config-file"},
-		{name: "--config-file=", args: []string{"--config-file=x.toml"}, want: "--config-file=x.toml"},
-		{name: "--model", args: []string{"--model", "foo"}, want: "--model"},
-		{name: "--model=", args: []string{"--model=foo"}, want: "--model=foo"},
-		{name: "-m", args: []string{"-m", "foo"}, want: "-m"},
-		{name: "-m=", args: []string{"-m=foo"}, want: "-m=foo"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateKimiPassthroughArgs(tt.args)
-			if err == nil {
-				t.Fatalf("expected error for args %v", tt.args)
-			}
-			if !strings.Contains(err.Error(), tt.want) {
-				t.Fatalf("error %q does not contain %q", err.Error(), tt.want)
-			}
-		})
-	}
-}
-
-func TestBuildKimiInlineConfig(t *testing.T) {
-	t.Setenv("OLLAMA_HOST", "http://127.0.0.1:11434")
-
-	cfg, err := buildKimiInlineConfig("llama3.2", 65536)
-	if err != nil {
-		t.Fatalf("buildKimiInlineConfig() error = %v", err)
-	}
-
-	var parsed map[string]any
-	if err := json.Unmarshal([]byte(cfg), &parsed); err != nil {
-		t.Fatalf("config is not valid JSON: %v", err)
-	}
-
-	if parsed["default_model"] != "ollama" {
-		t.Fatalf("default_model = %v, want ollama", parsed["default_model"])
-	}
-
-	providers, ok := parsed["providers"].(map[string]any)
-	if !ok {
-		t.Fatalf("providers missing or wrong type: %T", parsed["providers"])
-	}
-	ollamaProvider, ok := providers["ollama"].(map[string]any)
-	if !ok {
-		t.Fatalf("providers.ollama missing or wrong type: %T", providers["ollama"])
-	}
-	if ollamaProvider["type"] != "openai_legacy" {
-		t.Fatalf("provider type = %v, want openai_legacy", ollamaProvider["type"])
-	}
-	if ollamaProvider["base_url"] != "http://127.0.0.1:11434/v1" {
-		t.Fatalf("provider base_url = %v, want http://127.0.0.1:11434/v1", ollamaProvider["base_url"])
-	}
-	if ollamaProvider["api_key"] != "ollama" {
-		t.Fatalf("provider api_key = %v, want ollama", ollamaProvider["api_key"])
-	}
-
-	models, ok := parsed["models"].(map[string]any)
-	if !ok {
-		t.Fatalf("models missing or wrong type: %T", parsed["models"])
-	}
-	ollamaModel, ok := models["ollama"].(map[string]any)
-	if !ok {
-		t.Fatalf("models.ollama missing or wrong type: %T", models["ollama"])
-	}
-	if ollamaModel["provider"] != "ollama" {
-		t.Fatalf("model provider = %v, want ollama", ollamaModel["provider"])
-	}
-	if ollamaModel["model"] != "llama3.2" {
-		t.Fatalf("model model = %v, want llama3.2", ollamaModel["model"])
-	}
-	if ollamaModel["max_context_size"] != float64(65536) {
-		t.Fatalf("model max_context_size = %v, want 65536", ollamaModel["max_context_size"])
-	}
-}
-
-func TestBuildKimiInlineConfig_UsesConnectableHostForUnspecifiedBind(t *testing.T) {
-	t.Setenv("OLLAMA_HOST", "http://0.0.0.0:11434")
-
-	cfg, err := buildKimiInlineConfig("llama3.2", 65536)
-	if err != nil {
-		t.Fatalf("buildKimiInlineConfig() error = %v", err)
-	}
-
-	var parsed map[string]any
-	if err := json.Unmarshal([]byte(cfg), &parsed); err != nil {
-		t.Fatalf("config is not valid JSON: %v", err)
-	}
-
-	providers, ok := parsed["providers"].(map[string]any)
-	if !ok {
-		t.Fatalf("providers missing or wrong type: %T", parsed["providers"])
-	}
-
-	ollamaProvider, ok := providers["ollama"].(map[string]any)
-	if !ok {
-		t.Fatalf("providers.ollama missing or wrong type: %T", providers["ollama"])
-	}
-	if got, _ := ollamaProvider["base_url"].(string); got != "http://127.0.0.1:11434/v1" {
-		t.Fatalf("provider base_url = %q, want %q", got, "http://127.0.0.1:11434/v1")
-	}
-}
-
-func TestResolveKimiMaxContextSize(t *testing.T) {
-	t.Run("uses cloud limit when known", func(t *testing.T) {
-		got := resolveKimiMaxContextSize("kimi-k2.5:cloud")
-		if got != 262_144 {
-			t.Fatalf("resolveKimiMaxContextSize() = %d, want 262144", got)
-		}
-	})
-
-	t.Run("uses model show context length for local models", func(t *testing.T) {
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/show" {
-				http.NotFound(w, r)
-				return
-			}
-			fmt.Fprint(w, `{"model_info":{"llama.context_length":131072}}`)
-		}))
-		defer srv.Close()
-		t.Setenv("OLLAMA_HOST", srv.URL)
-
-		got := resolveKimiMaxContextSize("llama3.2")
-		if got != 131_072 {
-			t.Fatalf("resolveKimiMaxContextSize() = %d, want 131072", got)
-		}
-	})
-
-	t.Run("falls back to default when show fails", func(t *testing.T) {
-		srv := httptest.NewServer(http.NotFoundHandler())
-		defer srv.Close()
-		t.Setenv("OLLAMA_HOST", srv.URL)
-
-		oldTimeout := kimiModelShowTimeout
-		kimiModelShowTimeout = 100 * 1000 * 1000 // 100ms
-		t.Cleanup(func() { kimiModelShowTimeout = oldTimeout })
-
-		got := resolveKimiMaxContextSize("llama3.2")
-		if got != kimiDefaultMaxContextSize {
-			t.Fatalf("resolveKimiMaxContextSize() = %d, want %d", got, kimiDefaultMaxContextSize)
-		}
-	})
-}
-
-func TestKimiRun_RejectsConflictingArgsBeforeInstall(t *testing.T) {
-	k := &Kimi{}
-
-	oldConfirm := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
-		t.Fatalf("did not expect install prompt, got %q", prompt)
-		return false, nil
-	}
-	t.Cleanup(func() { DefaultConfirmPrompt = oldConfirm })
-
-	err := k.Run("llama3.2", []string{"--model", "other"})
-	if err == nil || !strings.Contains(err.Error(), "--model") {
-		t.Fatalf("expected conflict error mentioning --model, got %v", err)
-	}
-}
-
-func TestKimiRun_PassesInlineConfigAndExtraArgs(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("uses POSIX shell fake binary")
-	}
-
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-	logPath := filepath.Join(tmpDir, "kimi-args.log")
-	script := fmt.Sprintf(`#!/bin/sh
-for arg in "$@"; do
-  printf "%%s\n" "$arg" >> %q
-done
-exit 0
-`, logPath)
-	if err := os.WriteFile(filepath.Join(tmpDir, "kimi"), []byte(script), 0o755); err != nil {
-		t.Fatalf("failed to write fake kimi: %v", err)
-	}
-	t.Setenv("PATH", tmpDir)
-
-	srv := httptest.NewServer(http.NotFoundHandler())
-	defer srv.Close()
-	t.Setenv("OLLAMA_HOST", srv.URL)
-
-	k := &Kimi{}
-	if err := k.Run("llama3.2", []string{"--quiet", "--print"}); err != nil {
-		t.Fatalf("Run() error = %v", err)
-	}
-
-	data, err := os.ReadFile(logPath)
-	if err != nil {
-		t.Fatalf("failed to read args log: %v", err)
-	}
-	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
-	if len(lines) < 4 {
-		t.Fatalf("expected at least 4 args, got %v", lines)
-	}
-	if lines[0] != "--config" {
-		t.Fatalf("first arg = %q, want --config", lines[0])
-	}
-
-	var cfg map[string]any
-	if err := json.Unmarshal([]byte(lines[1]), &cfg); err != nil {
-		t.Fatalf("config arg is not valid JSON: %v", err)
-	}
-	providers := cfg["providers"].(map[string]any)
-	ollamaProvider := providers["ollama"].(map[string]any)
-	if ollamaProvider["type"] != "openai_legacy" {
-		t.Fatalf("provider type = %v, want openai_legacy", ollamaProvider["type"])
-	}
-
-	if lines[2] != "--quiet" || lines[3] != "--print" {
-		t.Fatalf("extra args = %v, want [--quiet --print]", lines[2:])
-	}
-}
-
-func TestEnsureKimiInstalled(t *testing.T) {
-	oldGOOS := kimiGOOS
-	t.Cleanup(func() { kimiGOOS = oldGOOS })
-
-	withConfirm := func(t *testing.T, fn func(prompt string) (bool, error)) {
-		t.Helper()
-		oldConfirm := DefaultConfirmPrompt
-		DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
-			return fn(prompt)
-		}
-		t.Cleanup(func() { DefaultConfirmPrompt = oldConfirm })
-	}
-
-	t.Run("already installed", func(t *testing.T) {
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		writeFakeBinary(t, tmpDir, "kimi")
-		kimiGOOS = runtime.GOOS
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			t.Fatalf("did not expect prompt, got %q", prompt)
-			return false, nil
-		})
-
-		bin, err := ensureKimiInstalled()
-		if err != nil {
-			t.Fatalf("ensureKimiInstalled() error = %v", err)
-		}
-		assertKimiBinPath(t, bin)
-	})
-
-	t.Run("missing dependencies", func(t *testing.T) {
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		kimiGOOS = "linux"
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			t.Fatalf("did not expect prompt, got %q", prompt)
-			return false, nil
-		})
-
-		_, err := ensureKimiInstalled()
-		if err == nil || !strings.Contains(err.Error(), "required dependencies are missing") {
-			t.Fatalf("expected missing dependency error, got %v", err)
-		}
-	})
-
-	t.Run("missing and user declines install", func(t *testing.T) {
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		writeFakeBinary(t, tmpDir, "curl")
-		writeFakeBinary(t, tmpDir, "bash")
-		kimiGOOS = "linux"
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			if !strings.Contains(prompt, "Kimi is not installed.") {
-				t.Fatalf("unexpected prompt: %q", prompt)
-			}
-			return false, nil
-		})
-
-		_, err := ensureKimiInstalled()
-		if err == nil || !strings.Contains(err.Error(), "installation cancelled") {
-			t.Fatalf("expected cancellation error, got %v", err)
-		}
-	})
-
-	t.Run("missing and user confirms install succeeds", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("uses POSIX shell fake binaries")
-		}
-
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		kimiGOOS = "linux"
-
-		writeFakeBinary(t, tmpDir, "curl")
-
-		installLog := filepath.Join(tmpDir, "bash.log")
-		kimiPath := filepath.Join(tmpDir, "kimi")
-		bashScript := fmt.Sprintf(`#!/bin/sh
-echo "$@" >> %q
-if [ "$1" = "-c" ]; then
-  /bin/cat > %q <<'EOS'
-#!/bin/sh
-exit 0
-EOS
-  /bin/chmod +x %q
-fi
-exit 0
-`, installLog, kimiPath, kimiPath)
-		if err := os.WriteFile(filepath.Join(tmpDir, "bash"), []byte(bashScript), 0o755); err != nil {
-			t.Fatalf("failed to write fake bash: %v", err)
-		}
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			return true, nil
-		})
-
-		bin, err := ensureKimiInstalled()
-		if err != nil {
-			t.Fatalf("ensureKimiInstalled() error = %v", err)
-		}
-		assertKimiBinPath(t, bin)
-
-		logData, err := os.ReadFile(installLog)
-		if err != nil {
-			t.Fatalf("failed to read install log: %v", err)
-		}
-		if !strings.Contains(string(logData), "https://code.kimi.com/install.sh") {
-			t.Fatalf("expected install.sh command in log, got:\n%s", string(logData))
-		}
-	})
-
-	t.Run("install succeeds and kimi is in home local bin without PATH update", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("uses POSIX shell fake binaries")
-		}
-
-		homeDir := t.TempDir()
-		setTestHome(t, homeDir)
-
-		tmpBin := t.TempDir()
-		t.Setenv("PATH", tmpBin)
-		kimiGOOS = "linux"
-		writeFakeBinary(t, tmpBin, "curl")
-
-		installedKimi := filepath.Join(homeDir, ".local", "bin", "kimi")
-		bashScript := fmt.Sprintf(`#!/bin/sh
-if [ "$1" = "-c" ]; then
-  /bin/mkdir -p %q
-  /bin/cat > %q <<'EOS'
-#!/bin/sh
-exit 0
-EOS
-  /bin/chmod +x %q
-fi
-exit 0
-`, filepath.Dir(installedKimi), installedKimi, installedKimi)
-		if err := os.WriteFile(filepath.Join(tmpBin, "bash"), []byte(bashScript), 0o755); err != nil {
-			t.Fatalf("failed to write fake bash: %v", err)
-		}
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			return true, nil
-		})
-
-		bin, err := ensureKimiInstalled()
-		if err != nil {
-			t.Fatalf("ensureKimiInstalled() error = %v", err)
-		}
-		if bin != installedKimi {
-			t.Fatalf("bin = %q, want %q", bin, installedKimi)
-		}
-	})
-
-	t.Run("install command fails", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("uses POSIX shell fake binaries")
-		}
-
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		kimiGOOS = "linux"
-		writeFakeBinary(t, tmpDir, "curl")
-		if err := os.WriteFile(filepath.Join(tmpDir, "bash"), []byte("#!/bin/sh\nexit 1\n"), 0o755); err != nil {
-			t.Fatalf("failed to write fake bash: %v", err)
-		}
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			return true, nil
-		})
-
-		_, err := ensureKimiInstalled()
-		if err == nil || !strings.Contains(err.Error(), "failed to install kimi") {
-			t.Fatalf("expected install failure error, got %v", err)
-		}
-	})
-
-	t.Run("install succeeds but binary missing on PATH", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("uses POSIX shell fake binaries")
-		}
-
-		setTestHome(t, t.TempDir())
-		tmpDir := t.TempDir()
-		t.Setenv("PATH", tmpDir)
-		kimiGOOS = "linux"
-		writeFakeBinary(t, tmpDir, "curl")
-		if err := os.WriteFile(filepath.Join(tmpDir, "bash"), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
-			t.Fatalf("failed to write fake bash: %v", err)
-		}
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			return true, nil
-		})
-
-		_, err := ensureKimiInstalled()
-		if err == nil || !strings.Contains(err.Error(), "binary was not found on PATH") {
-			t.Fatalf("expected PATH guidance error, got %v", err)
-		}
-	})
-}
-
-func TestKimiInstallerCommand(t *testing.T) {
-	tests := []struct {
-		name      string
-		goos      string
-		wantBin   string
-		wantParts []string
-		wantErr   bool
-	}{
-		{
-			name:      "linux",
-			goos:      "linux",
-			wantBin:   "bash",
-			wantParts: []string{"-c", "install.sh"},
-		},
-		{
-			name:      "darwin",
-			goos:      "darwin",
-			wantBin:   "bash",
-			wantParts: []string{"-c", "install.sh"},
-		},
-		{
-			name:      "windows",
-			goos:      "windows",
-			wantBin:   "powershell",
-			wantParts: []string{"-Command", "install.ps1"},
-		},
-		{
-			name:    "unsupported",
-			goos:    "freebsd",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			bin, args, err := kimiInstallerCommand(tt.goos)
-			if tt.wantErr {
-				if err == nil {
-					t.Fatal("expected error")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("kimiInstallerCommand() error = %v", err)
-			}
-			if bin != tt.wantBin {
-				t.Fatalf("bin = %q, want %q", bin, tt.wantBin)
-			}
-			joined := strings.Join(args, " ")
-			for _, part := range tt.wantParts {
-				if !strings.Contains(joined, part) {
-					t.Fatalf("args %q missing %q", joined, part)
-				}
-			}
-		})
-	}
-}

cmd/launch/launch.go

@@ -209,7 +209,6 @@ Supported integrations:
   copilot   Copilot CLI (aliases: copilot-cli)
   droid     Droid
   hermes    Hermes Agent
-  kimi      Kimi Code CLI
   opencode  OpenCode
   openclaw  OpenClaw (aliases: clawdbot, moltbot)
   pi        Pi
@@ -588,7 +587,7 @@ func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, nam
 		return nil
 	}
 
-	if (current == "" || needsConfigure || req.ModelOverride != "" || target != current) && !savedMatchesModels(saved, []string{target}) {
+	if current == "" || needsConfigure || req.ModelOverride != "" || target != current {
 		if err := prepareManagedSingleIntegration(name, runner, managed, target); err != nil {
 			return err
 		}

cmd/launch/launch_test.go

@@ -13,7 +13,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
 	"github.com/ollama/ollama/cmd/config"
 )
 
@@ -410,7 +409,7 @@ func TestLaunchIntegration_ManagedSingleIntegrationConfigOnlySkipsFinalRun(t *te
 	}
 }
 
-func TestLaunchIntegration_ManagedSingleIntegrationSkipsRewriteWhenSavedMatches(t *testing.T) {
+func TestLaunchIntegration_ManagedSingleIntegrationRepairsMissingLiveConfigUsingSavedModel(t *testing.T) {
 	tmpDir := t.TempDir()
 	setLaunchTestHome(t, tmpDir)
 	withInteractiveSession(t, true)
@@ -437,30 +436,29 @@ func TestLaunchIntegration_ManagedSingleIntegrationSkipsRewriteWhenSavedMatches(
 	withIntegrationOverride(t, "stubmanaged", runner)
 
 	DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {
-		t.Fatal("selector should not be called when saved model matches target")
+		t.Fatal("selector should not be called when saved model is reused for repair")
 		return "", nil
 	}
 	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
-		t.Fatal("confirm prompt should not run when saved model matches target")
-		return false, nil
+		return true, nil
 	}
 
 	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {
 		t.Fatalf("LaunchIntegration returned error: %v", err)
 	}
 
-	if len(runner.configured) != 0 {
-		t.Fatalf("expected Configure to be skipped when saved matches, got %v", runner.configured)
+	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
+		t.Fatalf("expected missing live config to be rewritten from saved model: %s", diff)
 	}
-	if runner.refreshCalls != 0 {
-		t.Fatalf("expected no runtime refresh when config is unchanged, got %d", runner.refreshCalls)
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected repaired config to refresh runtime once, got %d", runner.refreshCalls)
 	}
 	if runner.ranModel != "gemma4" {
-		t.Fatalf("expected launch to run saved model, got %q", runner.ranModel)
+		t.Fatalf("expected launch to use repaired saved model, got %q", runner.ranModel)
 	}
 }
 
-func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *testing.T) {
+func TestLaunchIntegration_ManagedSingleIntegrationConfigureOnlyRepairsMissingLiveConfig(t *testing.T) {
 	tmpDir := t.TempDir()
 	setLaunchTestHome(t, tmpDir)
 	withInteractiveSession(t, true)
@@ -468,8 +466,6 @@ func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *t
 
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
-		case "/api/tags":
-			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
 		case "/api/show":
 			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
 		default:
@@ -479,7 +475,7 @@ func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *t
 	defer srv.Close()
 	t.Setenv("OLLAMA_HOST", srv.URL)
 
-	if err := config.SaveIntegration("stubmanaged", []string{"old-model"}); err != nil {
+	if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {
 		t.Fatalf("failed to save managed integration config: %v", err)
 	}
 
@@ -487,7 +483,7 @@ func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *t
 	withIntegrationOverride(t, "stubmanaged", runner)
 
 	DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {
-		t.Fatal("selector should not be called when model override is provided")
+		t.Fatal("selector should not be called when saved model is reused for repair")
 		return "", nil
 	}
 	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
@@ -496,19 +492,19 @@ func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *t
 
 	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
 		Name:          "stubmanaged",
-		ModelOverride: "gemma4",
+		ConfigureOnly: true,
 	}); err != nil {
 		t.Fatalf("LaunchIntegration returned error: %v", err)
 	}
 
 	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
-		t.Fatalf("expected Configure to run when saved differs from target: %s", diff)
+		t.Fatalf("expected configure-only flow to rewrite missing live config: %s", diff)
 	}
 	if runner.refreshCalls != 1 {
-		t.Fatalf("expected runtime refresh once after configure, got %d", runner.refreshCalls)
+		t.Fatalf("expected configure-only repair to refresh runtime once, got %d", runner.refreshCalls)
 	}
-	if runner.ranModel != "gemma4" {
-		t.Fatalf("expected launch to run configured model, got %q", runner.ranModel)
+	if runner.ranModel != "" {
+		t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)
 	}
 }
 
@@ -1220,9 +1216,8 @@ func TestLaunchIntegration_EditorForceConfigure_FloatsCheckedModelsInPicker(t *t
 	if len(gotItems) == 0 {
 		t.Fatal("expected multi selector to receive items")
 	}
-	wantItems := recommendedNames()
-	if diff := cmp.Diff(wantItems, gotItems); diff != "" {
-		t.Fatalf("expected fixed recommended order in selector items (-want +got):\n%s", diff)
+	if gotItems[0] != "qwen3.5:cloud" {
+		t.Fatalf("expected checked models floated to top with qwen3.5:cloud first, got %v", gotItems)
 	}
 	if len(gotPreChecked) < 2 {
 		t.Fatalf("expected prechecked models to be preserved, got %v", gotPreChecked)

cmd/launch/models.go

@@ -21,7 +21,7 @@ import (
 )
 
 var recommendedModels = []ModelItem{
-	{Name: "kimi-k2.6:cloud", Description: "State-of-the-art coding, long-horizon execution, and multimodal agent swarm capability", Recommended: true},
+	{Name: "kimi-k2.5:cloud", Description: "Multimodal reasoning with subagents", Recommended: true},
 	{Name: "qwen3.5:cloud", Description: "Reasoning, coding, and agentic tool use with vision", Recommended: true},
 	{Name: "glm-5.1:cloud", Description: "Reasoning and code generation", Recommended: true},
 	{Name: "minimax-m2.7:cloud", Description: "Fast, efficient coding and real-world productivity", Recommended: true},
@@ -56,7 +56,6 @@ var cloudModelLimits = map[string]cloudModelLimit{
 	"gpt-oss:20b":         {Context: 131_072, Output: 131_072},
 	"kimi-k2:1t":          {Context: 262_144, Output: 262_144},
 	"kimi-k2.5":           {Context: 262_144, Output: 262_144},
-	"kimi-k2.6":           {Context: 262_144, Output: 262_144},
 	"kimi-k2-thinking":    {Context: 262_144, Output: 262_144},
 	"nemotron-3-nano:30b": {Context: 1_048_576, Output: 131_072},
 	"qwen3-coder:480b":    {Context: 262_144, Output: 65_536},
@@ -361,12 +360,18 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	}
 
 	if hasLocalModel || hasCloudModel {
-		// Keep the Recommended section pinned to recommendedModels order. Checked
-		// and default-model priority only apply within the More section.
 		slices.SortStableFunc(items, func(a, b ModelItem) int {
 			ac, bc := checked[a.Name], checked[b.Name]
 			aNew, bNew := notInstalled[a.Name], notInstalled[b.Name]
 			aRec, bRec := recRank[a.Name] > 0, recRank[b.Name] > 0
+			aCloud, bCloud := cloudModels[a.Name], cloudModels[b.Name]
+
+			if ac != bc {
+				if ac {
+					return -1
+				}
+				return 1
+			}
 			if aRec != bRec {
 				if aRec {
 					return -1
@@ -374,13 +379,13 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 				return 1
 			}
 			if aRec && bRec {
-				return recRank[a.Name] - recRank[b.Name]
-			}
-			if ac != bc {
-				if ac {
-					return -1
+				if aCloud != bCloud {
+					if aCloud {
+						return -1
+					}
+					return 1
 				}
-				return 1
+				return recRank[a.Name] - recRank[b.Name]
 			}
 			// Among checked non-recommended items - put the default first
 			if ac && !aRec && current != "" {

cmd/launch/openclaw.go

@@ -14,6 +14,8 @@ import (
 	"strings"
 	"time"
 
+	"golang.org/x/mod/semver"
+
 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/cmd/internal/fileutil"
 	"github.com/ollama/ollama/envconfig"
@@ -96,7 +98,9 @@ func (c *Openclaw) Run(model string, args []string) error {
 		patchDeviceScopes()
 	}
 
-	configureOllamaWebSearch()
+	if ensureWebSearchPlugin() {
+		registerWebSearchPlugin()
+	}
 
 	// When extra args are passed through, run exactly what the user asked for
 	// after setup and skip the built-in gateway+TUI convenience flow.
@@ -734,13 +738,89 @@ func clearSessionModelOverride(primary string) {
 	_ = os.WriteFile(path, out, 0o600)
 }
 
-// configureOllamaWebSearch keeps launch-managed OpenClaw installs on the
-// bundled Ollama web_search provider. Older launch builds installed an
-// external openclaw-web-search plugin that added custom ollama_web_search and
-// ollama_web_fetch tools. Current OpenClaw versions ship Ollama web_search as
-// the bundled "ollama" plugin instead, so we migrate stale config and ensure
-// fresh installs select the bundled provider.
-func configureOllamaWebSearch() {
+const (
+	webSearchNpmPackage = "@ollama/openclaw-web-search"
+	webSearchMinVersion = "0.2.1"
+)
+
+// ensureWebSearchPlugin installs the openclaw-web-search extension into the
+// user-level extensions directory (~/.openclaw/extensions/) if it isn't already
+// present, or re-installs if the installed version is older than webSearchMinVersion.
+// Returns true if the extension is available.
+func ensureWebSearchPlugin() bool {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
+	}
+
+	pluginDir := filepath.Join(home, ".openclaw", "extensions", "openclaw-web-search")
+	if webSearchPluginUpToDate(pluginDir) {
+		return true
+	}
+
+	npmBin, err := exec.LookPath("npm")
+	if err != nil {
+		return false
+	}
+
+	if err := os.MkdirAll(pluginDir, 0o755); err != nil {
+		return false
+	}
+
+	// Download the tarball via `npm pack`, extract it flat into the plugin dir.
+	pack := exec.Command(npmBin, "pack", webSearchNpmPackage, "--pack-destination", pluginDir)
+	out, err := pack.Output()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s  Warning: could not download web search plugin: %v%s\n", ansiYellow, err, ansiReset)
+		return false
+	}
+
+	tgzName := strings.TrimSpace(string(out))
+	tgzPath := filepath.Join(pluginDir, tgzName)
+	defer os.Remove(tgzPath)
+
+	tar := exec.Command("tar", "xzf", tgzPath, "--strip-components=1", "-C", pluginDir)
+	if err := tar.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "%s  Warning: could not extract web search plugin: %v%s\n", ansiYellow, err, ansiReset)
+		return false
+	}
+
+	fmt.Fprintf(os.Stderr, "%s  ✓ Installed Ollama web search %s\n", ansiGreen, ansiReset)
+	return true
+}
+
+// webSearchPluginUpToDate returns true if the plugin is installed and its
+// package.json version is >= webSearchMinVersion.
+func webSearchPluginUpToDate(pluginDir string) bool {
+	data, err := os.ReadFile(filepath.Join(pluginDir, "package.json"))
+	if err != nil {
+		return false
+	}
+	var pkg struct {
+		Version string `json:"version"`
+	}
+	if json.Unmarshal(data, &pkg) != nil || pkg.Version == "" {
+		return false
+	}
+	return !versionLessThan(pkg.Version, webSearchMinVersion)
+}
+
+// versionLessThan compares two semver version strings (major.minor.patch).
+// Inputs may omit the "v" prefix; it is added automatically for semver.Compare.
+func versionLessThan(a, b string) bool {
+	if !strings.HasPrefix(a, "v") {
+		a = "v" + a
+	}
+	if !strings.HasPrefix(b, "v") {
+		b = "v" + b
+	}
+	return semver.Compare(a, b) < 0
+}
+
+// registerWebSearchPlugin adds plugins.entries.openclaw-web-search to the OpenClaw
+// config so the gateway activates it on next start. Best-effort; silently returns
+// on any error.
+func registerWebSearchPlugin() {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return
@@ -755,8 +835,6 @@ func configureOllamaWebSearch() {
 		return
 	}
 
-	stalePluginConfigured := false
-
 	plugins, _ := config["plugins"].(map[string]any)
 	if plugins == nil {
 		plugins = make(map[string]any)
@@ -765,100 +843,68 @@ func configureOllamaWebSearch() {
 	if entries == nil {
 		entries = make(map[string]any)
 	}
+	entries["openclaw-web-search"] = map[string]any{"enabled": true}
+	plugins["entries"] = entries
+
+	// Pin trust so the gateway doesn't warn about untracked plugins.
+	allow, _ := plugins["allow"].([]any)
+	hasAllow := false
+	for _, v := range allow {
+		if s, ok := v.(string); ok && s == "openclaw-web-search" {
+			hasAllow = true
+			break
+		}
+	}
+	if !hasAllow {
+		allow = append(allow, "openclaw-web-search")
+	}
+	plugins["allow"] = allow
+
+	// Record install provenance so the loader can verify the plugin origin.
+	installs, _ := plugins["installs"].(map[string]any)
+	if installs == nil {
+		installs = make(map[string]any)
+	}
+	pluginDir := filepath.Join(home, ".openclaw", "extensions", "openclaw-web-search")
+	installs["openclaw-web-search"] = map[string]any{
+		"source":      "npm",
+		"spec":        webSearchNpmPackage,
+		"installPath": pluginDir,
+	}
+	plugins["installs"] = installs
+
+	config["plugins"] = plugins
+
+	// Add plugin tools to tools.alsoAllow so they survive the coding profile's
+	// policy pipeline (which has an explicit allow list of core tools only).
 	tools, _ := config["tools"].(map[string]any)
 	if tools == nil {
 		tools = make(map[string]any)
 	}
+
+	alsoAllow, _ := tools["alsoAllow"].([]any)
+	needed := []string{"ollama_web_search", "ollama_web_fetch"}
+	have := make(map[string]bool, len(alsoAllow))
+	for _, v := range alsoAllow {
+		if s, ok := v.(string); ok {
+			have[s] = true
+		}
+	}
+	for _, name := range needed {
+		if !have[name] {
+			alsoAllow = append(alsoAllow, name)
+		}
+	}
+	tools["alsoAllow"] = alsoAllow
+
+	// Disable built-in web search/fetch since our plugin replaces them.
 	web, _ := tools["web"].(map[string]any)
 	if web == nil {
 		web = make(map[string]any)
 	}
-	search, _ := web["search"].(map[string]any)
-	if search == nil {
-		search = make(map[string]any)
-	}
-	fetch, _ := web["fetch"].(map[string]any)
-	if fetch == nil {
-		fetch = make(map[string]any)
-	}
-
-	alsoAllow, _ := tools["alsoAllow"].([]any)
-	var filteredAlsoAllow []any
-	for _, v := range alsoAllow {
-		s, ok := v.(string)
-		if !ok {
-			filteredAlsoAllow = append(filteredAlsoAllow, v)
-			continue
-		}
-		if s == "ollama_web_search" || s == "ollama_web_fetch" {
-			stalePluginConfigured = true
-			continue
-		}
-		filteredAlsoAllow = append(filteredAlsoAllow, v)
-	}
-	if len(filteredAlsoAllow) > 0 {
-		tools["alsoAllow"] = filteredAlsoAllow
-	} else {
-		delete(tools, "alsoAllow")
-	}
-
-	if _, ok := entries["openclaw-web-search"]; ok {
-		delete(entries, "openclaw-web-search")
-		stalePluginConfigured = true
-	}
-	ollamaEntry, _ := entries["ollama"].(map[string]any)
-	if ollamaEntry == nil {
-		ollamaEntry = make(map[string]any)
-	}
-	ollamaEntry["enabled"] = true
-	entries["ollama"] = ollamaEntry
-	plugins["entries"] = entries
-
-	if allow, ok := plugins["allow"].([]any); ok {
-		var nextAllow []any
-		hasOllama := false
-		for _, v := range allow {
-			s, ok := v.(string)
-			if ok && s == "openclaw-web-search" {
-				stalePluginConfigured = true
-				continue
-			}
-			if ok && s == "ollama" {
-				hasOllama = true
-			}
-			nextAllow = append(nextAllow, v)
-		}
-		if !hasOllama {
-			nextAllow = append(nextAllow, "ollama")
-		}
-		plugins["allow"] = nextAllow
-	}
-
-	if installs, ok := plugins["installs"].(map[string]any); ok {
-		if _, exists := installs["openclaw-web-search"]; exists {
-			delete(installs, "openclaw-web-search")
-			stalePluginConfigured = true
-		}
-		if len(installs) > 0 {
-			plugins["installs"] = installs
-		} else {
-			delete(plugins, "installs")
-		}
-	}
-
-	if stalePluginConfigured || search["provider"] == nil {
-		search["provider"] = "ollama"
-	}
-	if stalePluginConfigured {
-		fetch["enabled"] = true
-	}
-	search["enabled"] = true
-	web["search"] = search
-	if len(fetch) > 0 {
-		web["fetch"] = fetch
-	}
+	web["search"] = map[string]any{"enabled": false}
+	web["fetch"] = map[string]any{"enabled": false}
 	tools["web"] = web
-	config["plugins"] = plugins
 	config["tools"] = tools
 
 	out, err := json.MarshalIndent(config, "", "  ")

cmd/launch/openclaw_test.go

@@ -2242,7 +2242,95 @@ func TestIntegrationOnboarded(t *testing.T) {
 	})
 }
 
-func TestConfigureOllamaWebSearch(t *testing.T) {
+func TestVersionLessThan(t *testing.T) {
+	tests := []struct {
+		a, b string
+		want bool
+	}{
+		{"0.1.7", "0.2.1", true},
+		{"0.2.0", "0.2.1", true},
+		{"0.2.1", "0.2.1", false},
+		{"0.2.2", "0.2.1", false},
+		{"1.0.0", "0.2.1", false},
+		{"0.2.1", "1.0.0", true},
+		{"v0.1.7", "0.2.1", true},
+		{"0.2.1", "v0.2.1", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.a+"_vs_"+tt.b, func(t *testing.T) {
+			if got := versionLessThan(tt.a, tt.b); got != tt.want {
+				t.Errorf("versionLessThan(%q, %q) = %v, want %v", tt.a, tt.b, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestWebSearchPluginUpToDate(t *testing.T) {
+	t.Run("missing directory", func(t *testing.T) {
+		if webSearchPluginUpToDate(filepath.Join(t.TempDir(), "nonexistent")) {
+			t.Error("expected false for missing directory")
+		}
+	})
+
+	t.Run("missing package.json", func(t *testing.T) {
+		dir := t.TempDir()
+		if webSearchPluginUpToDate(dir) {
+			t.Error("expected false for missing package.json")
+		}
+	})
+
+	t.Run("old version", func(t *testing.T) {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"version":"0.1.7"}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if webSearchPluginUpToDate(dir) {
+			t.Error("expected false for old version 0.1.7")
+		}
+	})
+
+	t.Run("exact minimum version", func(t *testing.T) {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"version":"0.2.1"}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if !webSearchPluginUpToDate(dir) {
+			t.Error("expected true for exact minimum version 0.2.1")
+		}
+	})
+
+	t.Run("newer version", func(t *testing.T) {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"version":"1.0.0"}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if !webSearchPluginUpToDate(dir) {
+			t.Error("expected true for newer version 1.0.0")
+		}
+	})
+
+	t.Run("invalid json", func(t *testing.T) {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`not json`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if webSearchPluginUpToDate(dir) {
+			t.Error("expected false for invalid json")
+		}
+	})
+
+	t.Run("empty version", func(t *testing.T) {
+		dir := t.TempDir()
+		if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"version":""}`), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if webSearchPluginUpToDate(dir) {
+			t.Error("expected false for empty version")
+		}
+	})
+}
+
+func TestRegisterWebSearchPlugin(t *testing.T) {
 	home := t.TempDir()
 	setTestHome(t, home)
 
@@ -2257,7 +2345,7 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		configureOllamaWebSearch()
+		registerWebSearchPlugin()
 
 		data, err := os.ReadFile(configPath)
 		if err != nil {
@@ -2273,30 +2361,40 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 			t.Fatal("plugins section missing")
 		}
 
+		// Check entries
 		entries, _ := plugins["entries"].(map[string]any)
-		entry, _ := entries["ollama"].(map[string]any)
+		entry, _ := entries["openclaw-web-search"].(map[string]any)
 		if enabled, _ := entry["enabled"].(bool); !enabled {
-			t.Error("expected entries.ollama.enabled = true")
-		}
-		if _, ok := entries["openclaw-web-search"]; ok {
-			t.Error("expected stale openclaw-web-search entry to be absent")
+			t.Error("expected entries.openclaw-web-search.enabled = true")
 		}
 
-		if _, ok := plugins["allow"]; ok {
-			t.Error("did not expect plugins.allow to be created when no allowlist exists")
+		// Check allow list
+		allow, _ := plugins["allow"].([]any)
+		found := false
+		for _, v := range allow {
+			if s, ok := v.(string); ok && s == "openclaw-web-search" {
+				found = true
+			}
 		}
-		if _, ok := plugins["installs"]; ok {
-			t.Error("did not expect plugins.installs to be created")
+		if !found {
+			t.Error("expected plugins.allow to contain openclaw-web-search")
 		}
 
-		tools, _ := config["tools"].(map[string]any)
-		web, _ := tools["web"].(map[string]any)
-		search, _ := web["search"].(map[string]any)
-		if got, _ := search["provider"].(string); got != "ollama" {
-			t.Errorf("search provider = %q, want %q", got, "ollama")
+		// Check install provenance
+		installs, _ := plugins["installs"].(map[string]any)
+		record, _ := installs["openclaw-web-search"].(map[string]any)
+		if record == nil {
+			t.Fatal("expected plugins.installs.openclaw-web-search")
 		}
-		if enabled, _ := search["enabled"].(bool); !enabled {
-			t.Error("expected tools.web.search.enabled = true")
+		if source, _ := record["source"].(string); source != "npm" {
+			t.Errorf("install source = %q, want %q", source, "npm")
+		}
+		if spec, _ := record["spec"].(string); spec != webSearchNpmPackage {
+			t.Errorf("install spec = %q, want %q", spec, webSearchNpmPackage)
+		}
+		expectedPath := filepath.Join(home, ".openclaw", "extensions", "openclaw-web-search")
+		if installPath, _ := record["installPath"].(string); installPath != expectedPath {
+			t.Errorf("installPath = %q, want %q", installPath, expectedPath)
 		}
 	})
 
@@ -2305,8 +2403,8 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		configureOllamaWebSearch()
-		configureOllamaWebSearch()
+		registerWebSearchPlugin()
+		registerWebSearchPlugin()
 
 		data, err := os.ReadFile(configPath)
 		if err != nil {
@@ -2318,39 +2416,30 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 		}
 
 		plugins, _ := config["plugins"].(map[string]any)
-		entries, _ := plugins["entries"].(map[string]any)
-		if len(entries) != 1 {
-			t.Fatalf("expected only bundled ollama entry, got %v", entries)
+		allow, _ := plugins["allow"].([]any)
+		count := 0
+		for _, v := range allow {
+			if s, ok := v.(string); ok && s == "openclaw-web-search" {
+				count++
+			}
 		}
-		if _, ok := entries["ollama"]; !ok {
-			t.Fatalf("expected entries.ollama to exist, got %v", entries)
+		if count != 1 {
+			t.Errorf("expected exactly 1 openclaw-web-search in allow, got %d", count)
 		}
 	})
 
-	t.Run("migrates stale plugin config and preserves unrelated settings", func(t *testing.T) {
+	t.Run("preserves existing config", func(t *testing.T) {
 		initial := map[string]any{
 			"plugins": map[string]any{
-				"allow": []any{"some-other-plugin", "openclaw-web-search"},
+				"allow": []any{"some-other-plugin"},
 				"entries": map[string]any{
-					"some-other-plugin":   map[string]any{"enabled": true},
-					"openclaw-web-search": map[string]any{"enabled": true},
+					"some-other-plugin": map[string]any{"enabled": true},
 				},
 				"installs": map[string]any{
 					"some-other-plugin": map[string]any{
 						"source":      "npm",
 						"installPath": "/some/path",
 					},
-					"openclaw-web-search": map[string]any{
-						"source":      "npm",
-						"installPath": "/old/path",
-					},
-				},
-			},
-			"tools": map[string]any{
-				"alsoAllow": []any{"ollama_web_search", "ollama_web_fetch", "browser"},
-				"web": map[string]any{
-					"search": map[string]any{"enabled": false},
-					"fetch":  map[string]any{"enabled": false},
 				},
 			},
 			"customField": "preserved",
@@ -2360,7 +2449,7 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		configureOllamaWebSearch()
+		registerWebSearchPlugin()
 
 		out, err := os.ReadFile(configPath)
 		if err != nil {
@@ -2380,61 +2469,28 @@ func TestConfigureOllamaWebSearch(t *testing.T) {
 		if entries["some-other-plugin"] == nil {
 			t.Error("existing plugin entry was lost")
 		}
-		if entries["openclaw-web-search"] != nil {
-			t.Error("stale openclaw-web-search entry should be removed")
-		}
-		if ollamaEntry, _ := entries["ollama"].(map[string]any); ollamaEntry == nil {
-			t.Fatal("expected bundled ollama entry to be enabled")
-		}
 
 		installs, _ := plugins["installs"].(map[string]any)
 		if installs["some-other-plugin"] == nil {
 			t.Error("existing install record was lost")
 		}
-		if installs["openclaw-web-search"] != nil {
-			t.Error("stale openclaw-web-search install record should be removed")
-		}
 
 		allow, _ := plugins["allow"].([]any)
-		hasOther, hasStalePlugin, hasOllama := false, false, false
+		hasOther, hasWebSearch := false, false
 		for _, v := range allow {
 			s, _ := v.(string)
 			if s == "some-other-plugin" {
 				hasOther = true
 			}
 			if s == "openclaw-web-search" {
-				hasStalePlugin = true
-			}
-			if s == "ollama" {
-				hasOllama = true
+				hasWebSearch = true
 			}
 		}
 		if !hasOther {
 			t.Error("existing allow entry was lost")
 		}
-		if hasStalePlugin {
-			t.Error("stale openclaw-web-search allow entry should be removed")
-		}
-		if !hasOllama {
-			t.Error("expected plugins.allow to contain bundled ollama plugin")
-		}
-
-		tools, _ := config["tools"].(map[string]any)
-		alsoAllow, _ := tools["alsoAllow"].([]any)
-		if len(alsoAllow) != 1 || alsoAllow[0] != "browser" {
-			t.Errorf("expected stale custom web tools to be removed, got %v", alsoAllow)
-		}
-		web, _ := tools["web"].(map[string]any)
-		search, _ := web["search"].(map[string]any)
-		fetch, _ := web["fetch"].(map[string]any)
-		if got, _ := search["provider"].(string); got != "ollama" {
-			t.Errorf("search provider = %q, want %q", got, "ollama")
-		}
-		if enabled, _ := search["enabled"].(bool); !enabled {
-			t.Error("expected migrated tools.web.search.enabled = true")
-		}
-		if enabled, _ := fetch["enabled"].(bool); !enabled {
-			t.Error("expected migrated tools.web.fetch.enabled = true")
+		if !hasWebSearch {
+			t.Error("openclaw-web-search not added to allow")
 		}
 	})
 }

cmd/launch/registry.go

@@ -33,7 +33,7 @@ type IntegrationInfo struct {
 	Description string
 }
 
-var launcherIntegrationOrder = []string{"openclaw", "claude", "opencode", "hermes", "codex", "copilot", "droid", "pi"}
+var launcherIntegrationOrder = []string{"openclaw", "claude", "opencode", "hermes", "codex", "droid", "pi"}
 
 var integrationSpecs = []*IntegrationSpec{
 	{
@@ -74,23 +74,6 @@ var integrationSpecs = []*IntegrationSpec{
 			Command: []string{"npm", "install", "-g", "@openai/codex"},
 		},
 	},
-	{
-		Name:        "kimi",
-		Runner:      &Kimi{},
-		Description: "Moonshot's coding agent for terminal and IDEs",
-		Hidden:      true,
-		Install: IntegrationInstallSpec{
-			CheckInstalled: func() bool {
-				_, err := exec.LookPath("kimi")
-				return err == nil
-			},
-			EnsureInstalled: func() error {
-				_, err := ensureKimiInstalled()
-				return err
-			},
-			URL: "https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html",
-		},
-	},
 	{
 		Name:        "copilot",
 		Runner:      &Copilot{},

cmd/launch/runner_exec_only_test.go

@@ -45,14 +45,6 @@ func TestEditorRunsDoNotRewriteConfig(t *testing.T) {
 				return filepath.Join(home, ".pi", "agent", "models.json")
 			},
 		},
-		{
-			name:   "kimi",
-			binary: "kimi",
-			runner: &Kimi{},
-			checkPath: func(home string) string {
-				return filepath.Join(home, ".kimi", "config.toml")
-			},
-		},
 	}
 
 	for _, tt := range tests {
@@ -65,10 +57,6 @@ func TestEditorRunsDoNotRewriteConfig(t *testing.T) {
 			if tt.name == "pi" {
 				writeFakeBinary(t, binDir, "npm")
 			}
-			if tt.name == "kimi" {
-				writeFakeBinary(t, binDir, "curl")
-				writeFakeBinary(t, binDir, "bash")
-			}
 			t.Setenv("PATH", binDir)
 
 			configPath := tt.checkPath(home)

docs/capabilities/structured-outputs.mdx

@@ -2,10 +2,6 @@
 title: Structured Outputs
 ---
 
-<Note>
-  Ollama's Cloud currently does not support structured outputs.
-</Note>
-
 Structured outputs let you enforce a JSON schema on model responses so you can reliably extract structured data, describe images, or keep every reply consistent.
 
 ## Generating structured JSON

docs/integrations/hermes.mdx

@@ -2,9 +2,7 @@
 title: Hermes Agent
 ---
 
-Hermes Agent is a self-improving AI agent built by Nous Research. It features automatic skill creation, cross-session memory, and 70+ skills that it ships with by default. 
-
-![Hermes Agent with Ollama](/images/hermes.png)
+Hermes Agent is a self-improving AI agent built by Nous Research. It features automatic skill creation, cross-session memory, and connects messaging platforms (Telegram, Discord, Slack, WhatsApp, Signal, Email) to models through a unified gateway.
 
 ## Quick start
 
@@ -12,56 +10,25 @@ Hermes Agent is a self-improving AI agent built by Nous Research. It features au
 ollama launch hermes
 ```
 
-Ollama handles everything automatically:
+### Pull a model
 
-1. **Install** — If Hermes isn't installed, Ollama prompts to install it via the Nous Research install script
-2. **Model** — Pick a model from the selector (local or cloud)
-3. **Onboarding** — Ollama configures the Ollama provider, points Hermes at `http://127.0.0.1:11434/v1`, and sets your model as the primary
-4. **Gateway** — Optionally connects a messaging platform (Telegram, Discord, Slack, WhatsApp, Signal, Email) and launches the Hermes chat
-
-<Note>Hermes on Windows requires WSL2. Install it with `wsl --install` and re-run from inside the WSL shell.</Note>
-
-## Recommended models
-
-**Cloud models**:
-
-- `kimi-k2.5:cloud` — Multimodal reasoning with subagents
-- `glm-5.1:cloud` — Reasoning and code generation
-- `qwen3.5:cloud` — Reasoning, coding, and agentic tool use with vision
-- `minimax-m2.7:cloud` — Fast, efficient coding and real-world productivity
-
-**Local models:**
-
-- `gemma4` — Reasoning and code generation locally (~16 GB VRAM)
-- `qwen3.6` — Reasoning, coding, and visual understanding locally (~24 GB VRAM)
-
-More models at [ollama.com/search](https://ollama.com/search?c=cloud).
-
-## Connect messaging apps
-
-Link Telegram, Discord, Slack, WhatsApp, Signal, or Email to chat with your models from anywhere:
+Before running the setup wizard, make sure you have a model available. Hermes will auto-detect models downloaded through Ollama.
 
 ```bash
-hermes gateway setup
+ollama pull kimi-k2.5:cloud
 ```
 
-## Reconfigure
+See [Recommended models](#recommended-models) for more options.
 
-Re-run the full setup wizard at any time:
-
-```bash
-hermes setup
-```
-
-## Manual setup
-
-If you'd rather drive Hermes's own wizard instead of `ollama launch hermes`, install it directly:
+### Install
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
 ```
 
-Hermes launches the setup wizard automatically. Choose **Quick setup**:
+### Set up
+
+After installation, Hermes launches the setup wizard automatically. Choose **Quick setup**:
 
 ```
 How would you like to set up Hermes?
@@ -117,3 +84,32 @@ Connect a messaging platform? (Telegram, Discord, etc.)
 Launch hermes chat now? [Y/n]: Y
 ```
 
+## Recommended models
+
+**Cloud models**:
+
+- `kimi-k2.5:cloud` — Multimodal reasoning with subagents
+- `qwen3.5:cloud` — Reasoning, coding, and agentic tool use with vision
+- `glm-5.1:cloud` — Reasoning and code generation
+- `minimax-m2.7:cloud` — Fast, efficient coding and real-world productivity
+
+**Local models:**
+
+- `gemma4` — Reasoning and code generation locally (~16 GB VRAM)
+- `qwen3.5` — Reasoning, coding, and visual understanding locally (~11 GB VRAM)
+
+More models at [ollama.com/search](https://ollama.com/models).
+
+## Configure later
+
+Re-run the setup wizard at any time:
+
+```bash
+hermes setup
+```
+
+To configure just messaging:
+
+```bash
+hermes setup gateway
+```

docs/integrations/openclaw.mdx

@@ -15,7 +15,7 @@ Ollama handles everything automatically:
 1. **Install** — If OpenClaw isn't installed, Ollama prompts to install it via npm
 2. **Security** — On the first launch, a security notice explains the risks of tool access
 3. **Model** — Pick a model from the selector (local or cloud)
-4. **Onboarding** — Ollama configures the provider, installs the gateway daemon, sets your model as the primary, and enables OpenClaw's bundled Ollama web search
+4. **Onboarding** — Ollama configures the provider, installs the gateway daemon, sets your model as the primary, and installs the web search and fetch plugin
 5. **Gateway** — Starts in the background and opens the OpenClaw TUI
 
 <Note>OpenClaw requires a larger context window. It is recommended to use a context window of at least 64k tokens if using local models. See [Context length](/context-length) for more information.</Note>
@@ -24,19 +24,19 @@ Ollama handles everything automatically:
 
 ## Web search and fetch
 
-OpenClaw ships with a bundled Ollama `web_search` provider that lets local or cloud-backed Ollama setups search the web through the configured Ollama host.
+OpenClaw ships with a web search and fetch plugin that gives local or cloud models the ability to search the web and extract readable page content.
 
 ```bash
 ollama launch openclaw
 ```
 
-Ollama web search is enabled automatically when launching OpenClaw through Ollama. To configure it manually:
+Web search and fetch is enabled automatically when launching OpenClaw through Ollama. To install the plugin directly:
 
 ```bash
-openclaw configure --section web
+openclaw plugins install @ollama/openclaw-web-search
 ```
 
-<Note>Ollama web search for local models requires `ollama signin`.</Note>
+<Note>Web search for local models requires `ollama signin`.</Note>
 
 ## Configure without launching
 
@@ -93,3 +93,4 @@ Link WhatsApp, Telegram, Slack, Discord, or iMessage to chat with your local mod
 ```bash
 openclaw gateway stop
 ```
+

integration/api_test.go

@@ -406,6 +406,10 @@ func TestAPIShowModel(t *testing.T) {
 }
 
 func TestAPIGenerateLogprobs(t *testing.T) {
+	if testModel != "" {
+		// Logprobs requires runner support (e.g. llama.cpp has it, MLX does not).
+		t.Skip("logprobs not supported by all runners")
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
 	defer cancel()
 
@@ -519,6 +523,10 @@ func TestAPIGenerateLogprobs(t *testing.T) {
 }
 
 func TestAPIChatLogprobs(t *testing.T) {
+	if testModel != "" {
+		// Logprobs requires runner support (e.g. llama.cpp has it, MLX does not).
+		t.Skip("logprobs not supported by all runners")
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
 	defer cancel()
 

manifest/layer.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"time"
 )
 
 type Layer struct {
@@ -61,9 +60,6 @@ func NewLayer(r io.Reader, mediatype string) (Layer, error) {
 			return Layer{}, err
 		}
 	}
-	if err := touchLayer(blob); err != nil {
-		return Layer{}, err
-	}
 
 	return Layer{
 		MediaType: mediatype,
@@ -87,9 +83,6 @@ func NewLayerFromLayer(digest, mediatype, from string) (Layer, error) {
 	if err != nil {
 		return Layer{}, err
 	}
-	if err := touchLayer(blob); err != nil {
-		return Layer{}, err
-	}
 
 	return Layer{
 		MediaType: mediatype,
@@ -100,11 +93,6 @@ func NewLayerFromLayer(digest, mediatype, from string) (Layer, error) {
 	}, nil
 }
 
-func touchLayer(path string) error {
-	now := time.Now()
-	return os.Chtimes(path, now, now)
-}
-
 func (l *Layer) Open() (io.ReadSeekCloser, error) {
 	if l.Digest == "" {
 		return nil, errors.New("opening layer with empty digest")

model/renderers/gemma4.go

@@ -12,8 +12,7 @@ import (
 // <|turn>/<turn|> markers, <|"|> string delimiters, and <|tool>/
 // <|tool_call>/<|tool_response> tags for function calling.
 type Gemma4Renderer struct {
-	useImgTags          bool
-	emptyBlockOnNothink bool
+	useImgTags bool
 }
 
 const (
@@ -125,9 +124,6 @@ func (r *Gemma4Renderer) Render(messages []api.Message, tools []api.Tool, thinkV
 	// Generation prompt.
 	if prevMessageType != "tool_response" && prevMessageType != "tool_call" {
 		sb.WriteString("<|turn>model\n")
-		if r.emptyBlockOnNothink && !hasThink {
-			sb.WriteString("<|channel>thought\n<channel|>")
-		}
 	}
 
 	return sb.String(), nil

model/renderers/gemma4_reference_test.go

@@ -3,9 +3,9 @@ package renderers
 // TestGemma4RendererMatchesReference verifies our renderer matches the checked-in
 // Gemma 4 reference template.
 //
-// Current upstream Gemma 4 chat templates differ by model size. The checked-in
-// reference cases below use the small (e2b/e4b-style) baseline, with large
-// (26b/31b-style) checks covered separately in this file.
+// Current upstream Gemma 4 chat templates differ by model size, so the checked-in
+// reference intentionally uses the shared baseline without an empty generation-time
+// thought channel until renderer selection is split by size.
 //
 // To regenerate expected values, save the E2B template to
 // gemma4_e2b_chat_template.jinja2 and run:
@@ -1474,47 +1474,6 @@ Hi<turn|>
 	}
 }
 
-func TestGemma4RendererVariantsMatchExpectedGenerationPrompt(t *testing.T) {
-	messages := []api.Message{{Role: "user", Content: "Hello"}}
-
-	tests := []struct {
-		name         string
-		rendererName string
-		expected     string
-	}{
-		{
-			name:         "legacy_alias",
-			rendererName: "gemma4",
-			expected:     "<bos><|turn>user\nHello<turn|>\n<|turn>model\n",
-		},
-		{
-			name:         "small",
-			rendererName: "gemma4-small",
-			expected:     "<bos><|turn>user\nHello<turn|>\n<|turn>model\n",
-		},
-		{
-			name:         "large",
-			rendererName: "gemma4-large",
-			expected:     "<bos><|turn>user\nHello<turn|>\n<|turn>model\n<|channel>thought\n<channel|>",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := RenderWithRenderer(tt.rendererName, messages, nil, nil)
-			assert.NoError(t, err)
-			assert.Equal(t, tt.expected, got)
-		})
-	}
-}
-
-func TestGemma4LargeRendererOmitsEmptyThoughtBlockWhenThinkingEnabled(t *testing.T) {
-	got, err := RenderWithRenderer("gemma4-large", []api.Message{{Role: "user", Content: "Hello"}}, nil, thinkTrue())
-	assert.NoError(t, err)
-	assert.Equal(t, "<bos><|turn>system\n<|think|>\n<turn|>\n<|turn>user\nHello<turn|>\n<|turn>model\n", got)
-	assert.NotContains(t, got, "<|channel>thought\n<channel|>")
-}
-
 func TestGemma4RendererMatchesJinja2ExpandedParity(t *testing.T) {
 	if os.Getenv("VERIFY_JINJA2") == "" {
 		t.Skip("set VERIFY_JINJA2=1 to run expanded Jinja2 parity checks")
@@ -1657,35 +1616,15 @@ func TestGemma4RendererMatchesJinja2ExpandedParity(t *testing.T) {
 		},
 	}
 
-	variants := []struct {
-		name        string
-		renderer    *Gemma4Renderer
-		templateRel string
-	}{
-		{
-			name:        "small",
-			renderer:    &Gemma4Renderer{useImgTags: RenderImgTags},
-			templateRel: gemma4E2BTemplate,
-		},
-		{
-			name:        "large",
-			renderer:    &Gemma4Renderer{useImgTags: RenderImgTags, emptyBlockOnNothink: true},
-			templateRel: gemma431BTemplate,
-		},
-	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			renderer := &Gemma4Renderer{useImgTags: RenderImgTags}
+			got, err := renderer.Render(tt.messages, tt.tools, tt.think)
+			assert.NoError(t, err)
 
-	for _, variant := range variants {
-		t.Run(variant.name, func(t *testing.T) {
-			for _, tt := range tests {
-				t.Run(tt.name, func(t *testing.T) {
-					got, err := variant.renderer.Render(tt.messages, tt.tools, tt.think)
-					assert.NoError(t, err)
-
-					jinja2Output := renderWithJinja2Template(t, variant.templateRel, tt.messages, tt.tools, tt.think)
-					assert.Equal(t, jinja2Output, got,
-						"renderer output doesn't match Jinja2 template output")
-				})
-			}
+			jinja2Output := renderWithJinja2(t, tt.messages, tt.tools, tt.think)
+			assert.Equal(t, jinja2Output, got,
+				"renderer output doesn't match Jinja2 template output")
 		})
 	}
 }

model/renderers/renderer.go

@@ -81,10 +81,8 @@ func rendererForName(name string) Renderer {
 		return renderer
 	case "nemotron-3-nano":
 		return &Nemotron3NanoRenderer{}
-	case "gemma4", "gemma4-small":
+	case "gemma4":
 		return &Gemma4Renderer{useImgTags: RenderImgTags}
-	case "gemma4-large":
-		return &Gemma4Renderer{useImgTags: RenderImgTags, emptyBlockOnNothink: true}
 	case "functiongemma":
 		return &FunctionGemmaRenderer{}
 	case "glm-4.7":

server/create.go

@@ -523,7 +523,7 @@ func createModel(r api.CreateRequest, name model.Name, baseLayers []*layerGGML,
 				arch := layer.GGML.KV().Architecture()
 				switch arch {
 				case "gemma4":
-					config.Renderer = cmp.Or(config.Renderer, gemma4RendererLegacy)
+					config.Renderer = cmp.Or(config.Renderer, "gemma4")
 					config.Parser = cmp.Or(config.Parser, "gemma4")
 					if _, ok := r.Parameters["stop"]; !ok {
 						if r.Parameters == nil {

server/gemma4_test.go

@@ -1,78 +0,0 @@
-package server
-
-import "testing"
-
-func TestResolveGemma4Renderer(t *testing.T) {
-	tests := []struct {
-		name  string
-		model *Model
-		want  string
-	}{
-		{
-			name:  "nil model falls back to legacy alias",
-			model: nil,
-			want:  gemma4RendererLegacy,
-		},
-		{
-			name: "explicit small passes through",
-			model: &Model{
-				Config: testConfigWithRenderer(gemma4RendererSmall),
-			},
-			want: gemma4RendererSmall,
-		},
-		{
-			name: "explicit large passes through",
-			model: &Model{
-				Config: testConfigWithRenderer(gemma4RendererLarge),
-			},
-			want: gemma4RendererLarge,
-		},
-		{
-			name: "legacy e4b tag resolves small",
-			model: &Model{
-				Name:      "gemma4:e4b",
-				ShortName: "gemma4:e4b",
-				Config:    testConfigWithRenderer(gemma4RendererLegacy),
-			},
-			want: gemma4RendererSmall,
-		},
-		{
-			name: "legacy 31b tag resolves large",
-			model: &Model{
-				Name:      "gemma4:31b-cloud",
-				ShortName: "gemma4:31b-cloud",
-				Config:    testConfigWithRenderer(gemma4RendererLegacy),
-			},
-			want: gemma4RendererLarge,
-		},
-		{
-			name: "legacy model type resolves small",
-			model: &Model{
-				Config: testConfigWithRendererAndType(gemma4RendererLegacy, "4.3B"),
-			},
-			want: gemma4RendererSmall,
-		},
-		{
-			name: "legacy model type resolves large",
-			model: &Model{
-				Config: testConfigWithRendererAndType(gemma4RendererLegacy, "25.2B"),
-			},
-			want: gemma4RendererLarge,
-		},
-		{
-			name: "legacy unknown defaults small",
-			model: &Model{
-				Config: testConfigWithRenderer(gemma4RendererLegacy),
-			},
-			want: gemma4RendererSmall,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := resolveGemma4Renderer(tt.model); got != tt.want {
-				t.Fatalf("resolveGemma4Renderer() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}

server/images.go

@@ -19,7 +19,6 @@ import (
 	"slices"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/envconfig"
@@ -34,10 +33,6 @@ import (
 	"github.com/ollama/ollama/x/imagegen/transfer"
 )
 
-// Blobs newer than this may belong to another process that has not written its
-// manifest yet. They become eligible for the normal mark-and-sweep pass later.
-const layerPruneGracePeriod = time.Hour
-
 var (
 	errCapabilities         = errors.New("does not support")
 	errCapabilityCompletion = errors.New("completion")
@@ -161,7 +156,7 @@ func (m *Model) Capabilities() []model.Capability {
 
 	// Temporary workaround — suppress vision/audio for gemma4 MLX models
 	// until multimodal runtime pipeline lands. Remove when imageproc.go is wired up.
-	if m.Config.ModelFormat == "safetensors" && isGemma4Renderer(m.Config.Renderer) {
+	if m.Config.ModelFormat == "safetensors" && m.Config.Renderer == "gemma4" {
 		capabilities = slices.DeleteFunc(capabilities, func(c model.Capability) bool {
 			return c == model.CapabilityVision || c == "audio"
 		})
@@ -483,23 +478,10 @@ func PruneLayers() error {
 	}
 
 	for _, blob := range blobs {
-		if blob.IsDir() {
-			continue
-		}
-
-		info, err := blob.Info()
-		if err != nil {
-			slog.Error("couldn't stat blob", "blob", blob.Name(), "error", err)
-			continue
-		}
-		if time.Since(info.ModTime()) < layerPruneGracePeriod {
-			continue
-		}
-
 		name := blob.Name()
 		name = strings.ReplaceAll(name, "-", ":")
 
-		_, err = manifest.BlobsPath(name)
+		_, err := manifest.BlobsPath(name)
 		if err != nil {
 			if errors.Is(err, manifest.ErrInvalidDigestFormat) {
 				// remove invalid blobs (e.g. partial downloads)

server/images_test.go

@@ -5,58 +5,14 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/ollama/ollama/fs/ggml"
-	"github.com/ollama/ollama/manifest"
 	"github.com/ollama/ollama/template"
 	"github.com/ollama/ollama/types/model"
 )
 
-func TestPruneLayersSkipsRecentOrphans(t *testing.T) {
-	t.Setenv("OLLAMA_MODELS", t.TempDir())
-
-	recentDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000001"
-	oldDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000002"
-
-	for _, digest := range []string{recentDigest, oldDigest} {
-		p, err := manifest.BlobsPath(digest)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(p, nil, 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	oldPath, err := manifest.BlobsPath(oldDigest)
-	if err != nil {
-		t.Fatal(err)
-	}
-	oldTime := time.Now().Add(-layerPruneGracePeriod - time.Hour)
-	if err := os.Chtimes(oldPath, oldTime, oldTime); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := PruneLayers(); err != nil {
-		t.Fatal(err)
-	}
-
-	recentPath, err := manifest.BlobsPath(recentDigest)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(recentPath); err != nil {
-		t.Fatalf("recent orphan was pruned: %v", err)
-	}
-	if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
-		t.Fatalf("old orphan still exists: %v", err)
-	}
-}
-
 func TestModelCapabilities(t *testing.T) {
 	// Create completion model (llama architecture without vision)
 	completionModelPath, _ := createBinFile(t, ggml.KV{
@@ -162,39 +118,6 @@ func TestModelCapabilities(t *testing.T) {
 			},
 			expectedCaps: []model.Capability{model.CapabilityEmbedding},
 		},
-		{
-			name: "gemma4 small safetensors suppresses vision and audio",
-			model: Model{
-				Config: model.ConfigV2{
-					ModelFormat:  "safetensors",
-					Renderer:     gemma4RendererSmall,
-					Capabilities: []string{"vision", "audio"},
-				},
-				Template: chatTemplate,
-			},
-		},
-		{
-			name: "gemma4 large safetensors suppresses vision and audio",
-			model: Model{
-				Config: model.ConfigV2{
-					ModelFormat:  "safetensors",
-					Renderer:     gemma4RendererLarge,
-					Capabilities: []string{"vision", "audio"},
-				},
-				Template: chatTemplate,
-			},
-		},
-		{
-			name: "legacy gemma4 safetensors suppresses vision and audio",
-			model: Model{
-				Config: model.ConfigV2{
-					ModelFormat:  "safetensors",
-					Renderer:     gemma4RendererLegacy,
-					Capabilities: []string{"vision", "audio"},
-				},
-				Template: chatTemplate,
-			},
-		},
 	}
 
 	// compare two slices of model.Capability regardless of order

server/prompt.go

@@ -115,8 +115,7 @@ func chatPrompt(ctx context.Context, m *Model, tokenize tokenizeFunc, opts *api.
 
 func renderPrompt(m *Model, msgs []api.Message, tools []api.Tool, think *api.ThinkValue) (string, error) {
 	if m.Config.Renderer != "" {
-		rendererName := resolveRendererName(m)
-		rendered, err := renderers.RenderWithRenderer(rendererName, msgs, tools, think)
+		rendered, err := renderers.RenderWithRenderer(m.Config.Renderer, msgs, tools, think)
 		if err != nil {
 			return "", err
 		}

server/prompt_test.go

@@ -13,14 +13,6 @@ import (
 	"github.com/ollama/ollama/types/model"
 )
 
-func testConfigWithRenderer(renderer string) model.ConfigV2 {
-	return model.ConfigV2{Renderer: renderer}
-}
-
-func testConfigWithRendererAndType(renderer, modelType string) model.ConfigV2 {
-	return model.ConfigV2{Renderer: renderer, ModelType: modelType}
-}
-
 func TestChatPrompt(t *testing.T) {
 	type expect struct {
 		prompt string
@@ -405,43 +397,3 @@ func TestChatPromptGLMOcrRendererAddsImageTags(t *testing.T) {
 		t.Fatalf("prompt missing glm-ocr image tags, got: %q", prompt)
 	}
 }
-
-func TestRenderPromptResolvesDynamicGemma4Renderer(t *testing.T) {
-	msgs := []api.Message{{Role: "user", Content: "Hello"}}
-
-	tests := []struct {
-		name  string
-		model Model
-		want  string
-	}{
-		{
-			name: "small from name",
-			model: Model{
-				Name:      "gemma4:e4b",
-				ShortName: "gemma4:e4b",
-				Config:    testConfigWithRenderer(gemma4RendererLegacy),
-			},
-			want: "<bos><|turn>user\nHello<turn|>\n<|turn>model\n",
-		},
-		{
-			name: "large from model type",
-			model: Model{
-				Config: testConfigWithRendererAndType(gemma4RendererLegacy, "25.2B"),
-			},
-			want: "<bos><|turn>user\nHello<turn|>\n<|turn>model\n<|channel>thought\n<channel|>",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := renderPrompt(&tt.model, msgs, nil, nil)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			if diff := cmp.Diff(got, tt.want); diff != "" {
-				t.Fatalf("rendered prompt mismatch (-got +want):\n%s", diff)
-			}
-		})
-	}
-}

server/renderer_resolution.go

@@ -1,110 +0,0 @@
-package server
-
-import (
-	"strconv"
-	"strings"
-
-	"github.com/ollama/ollama/format"
-)
-
-const (
-	gemma4RendererLegacy = "gemma4"
-	gemma4RendererSmall  = "gemma4-small"
-	gemma4RendererLarge  = "gemma4-large"
-
-	// Gemma 4 small templates cover the e2b/e4b family, while 26b/31b use the
-	// large template. Default to the small prompt unless the model is clearly in
-	// the large range.
-	gemma4LargeMinParameterCount = 16_000_000_000
-)
-
-func resolveRendererName(m *Model) string {
-	if m == nil || m.Config.Renderer == "" {
-		return ""
-	}
-
-	switch m.Config.Renderer {
-	case gemma4RendererLegacy:
-		return resolveGemma4Renderer(m)
-	default:
-		return m.Config.Renderer
-	}
-}
-
-func resolveGemma4Renderer(m *Model) string {
-	if m == nil || m.Config.Renderer != gemma4RendererLegacy {
-		if m == nil {
-			return gemma4RendererLegacy
-		}
-		return m.Config.Renderer
-	}
-
-	if renderer, ok := gemma4RendererFromName(m.ShortName); ok {
-		return renderer
-	}
-
-	if renderer, ok := gemma4RendererFromName(m.Name); ok {
-		return renderer
-	}
-
-	if parameterCount, ok := parseHumanParameterCount(m.Config.ModelType); ok {
-		return gemma4RendererForParameterCount(parameterCount)
-	}
-
-	return gemma4RendererSmall
-}
-
-func gemma4RendererForParameterCount(parameterCount uint64) string {
-	if parameterCount >= gemma4LargeMinParameterCount {
-		return gemma4RendererLarge
-	}
-
-	return gemma4RendererSmall
-}
-
-func gemma4RendererFromName(name string) (string, bool) {
-	lower := strings.ToLower(name)
-	switch {
-	case strings.Contains(lower, "e2b"), strings.Contains(lower, "e4b"):
-		return gemma4RendererSmall, true
-	case strings.Contains(lower, "26b"), strings.Contains(lower, "31b"):
-		return gemma4RendererLarge, true
-	default:
-		return "", false
-	}
-}
-
-func parseHumanParameterCount(s string) (uint64, bool) {
-	if s == "" {
-		return 0, false
-	}
-
-	unit := strings.ToUpper(s[len(s)-1:])
-	var multiplier float64
-	switch unit {
-	case "B":
-		multiplier = float64(format.Billion)
-	case "M":
-		multiplier = float64(format.Million)
-	case "K":
-		multiplier = float64(format.Thousand)
-	default:
-		return 0, false
-	}
-
-	value, err := strconv.ParseFloat(s[:len(s)-1], 64)
-	if err != nil {
-		return 0, false
-	}
-
-	return uint64(value * multiplier), true
-}
-
-func isGemma4Renderer(renderer string) bool {
-	switch renderer {
-	case gemma4RendererLegacy, gemma4RendererSmall, gemma4RendererLarge:
-		return true
-	default:
-		return false
-	}
-}

server/routes.go

@@ -2408,10 +2408,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 			// current approach uses the transition from parsed thinking content to
 			// parsed non-thinking content as the signal to turn constraining on
 
-			// TODO(parthsareen): temporary fix for https://github.com/ollama/ollama/issues/15260.
-			// To revisit for other models and have a consistent pattern across models through parsers.
-			forceImmediate := m.Config.Parser == "gemma4" && req.Think != nil && !req.Think.Bool()
-			if req.Format != nil && structuredOutputsState == structuredOutputsState_None && !forceImmediate && ((builtinParser != nil || thinkingState != nil) && slices.Contains(m.Capabilities(), model.CapabilityThinking)) {
+			if req.Format != nil && structuredOutputsState == structuredOutputsState_None && ((builtinParser != nil || thinkingState != nil) && slices.Contains(m.Capabilities(), model.CapabilityThinking)) {
 				currentFormat = nil
 			}
 

server/routes_create_test.go

@@ -928,59 +928,6 @@ func TestCreateDetectTemplate(t *testing.T) {
 	})
 }
 
-func TestCreateGemma4KeepsDynamicRendererAlias(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	p := t.TempDir()
-	t.Setenv("OLLAMA_MODELS", p)
-	var s Server
-
-	_, digest := createBinFile(t, ggml.KV{
-		"general.architecture":    "gemma4",
-		"general.parameter_count": uint64(25_200_000_000),
-	}, nil)
-
-	w := createRequest(t, s.CreateHandler, api.CreateRequest{
-		Name:   "test",
-		Files:  map[string]string{"test.gguf": digest},
-		Stream: &stream,
-	})
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected status code 200, actual %d", w.Code)
-	}
-
-	mf, err := manifest.ParseNamedManifest(model.ParseName("test"))
-	if err != nil {
-		t.Fatalf("parse manifest: %v", err)
-	}
-	if mf.Config.Digest == "" {
-		t.Fatalf("unexpected empty config digest for manifest")
-	}
-
-	configPath, err := manifest.BlobsPath(mf.Config.Digest)
-	if err != nil {
-		t.Fatalf("config blob path: %v", err)
-	}
-
-	cfgFile, err := os.Open(configPath)
-	if err != nil {
-		t.Fatalf("open config blob: %v", err)
-	}
-	defer cfgFile.Close()
-
-	var cfg model.ConfigV2
-	if err := json.NewDecoder(cfgFile).Decode(&cfg); err != nil {
-		t.Fatalf("decode config: %v", err)
-	}
-
-	if cfg.Renderer != gemma4RendererLegacy {
-		t.Fatalf("expected renderer %q, got %q", gemma4RendererLegacy, cfg.Renderer)
-	}
-	if cfg.Parser != "gemma4" {
-		t.Fatalf("expected parser %q, got %q", "gemma4", cfg.Parser)
-	}
-}
-
 func TestDetectModelTypeFromFiles(t *testing.T) {
 	t.Run("gguf file", func(t *testing.T) {
 		_, digest := createBinFile(t, nil, nil)

server/routes_generate_test.go

@@ -2108,132 +2108,6 @@ func TestChatWithPromptEndingInThinkTag(t *testing.T) {
 	})
 }
 
-// TestChatFormatWithThinkFalse verifies that when a model uses a builtin
-// parser that supports thinking (e.g. gemma4) and the request explicitly
-// disables thinking (think=false), the format constraint is passed to the
-// first and only completion call. Previously, format was deferred for all
-// thinking-capable parsers and only re-applied after an end-of-thinking
-// transition — a transition that never fires when thinking is off. See
-// https://github.com/ollama/ollama/issues/15260.
-func TestChatFormatWithThinkFalse(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	mock := &mockRunner{
-		CompletionResponse: llm.CompletionResponse{
-			Done:               true,
-			DoneReason:         llm.DoneReasonStop,
-			PromptEvalCount:    1,
-			PromptEvalDuration: 1,
-			EvalCount:          1,
-			EvalDuration:       1,
-		},
-	}
-
-	s := &Server{
-		sched: &Scheduler{
-			pendingReqCh:    make(chan *LlmRequest, 1),
-			finishedReqCh:   make(chan *LlmRequest, 1),
-			expiredCh:       make(chan *runnerRef, 1),
-			unloadedCh:      make(chan any, 1),
-			loaded:          make(map[string]*runnerRef),
-			newServerFn:     newMockServer(mock),
-			getGpuFn:        getGpuFn,
-			getSystemInfoFn: getSystemInfoFn,
-			waitForRecovery: 250 * time.Millisecond,
-			loadFn: func(req *LlmRequest, _ ml.SystemInfo, _ []ml.DeviceInfo, _ bool) bool {
-				time.Sleep(time.Millisecond)
-				req.successCh <- &runnerRef{llama: mock}
-				return false
-			},
-		},
-	}
-
-	go s.sched.Run(t.Context())
-
-	_, digest := createBinFile(t, ggml.KV{
-		"general.architecture":          "llama",
-		"llama.block_count":             uint32(1),
-		"llama.context_length":          uint32(8192),
-		"llama.embedding_length":        uint32(4096),
-		"llama.attention.head_count":    uint32(32),
-		"llama.attention.head_count_kv": uint32(8),
-		"tokenizer.ggml.tokens":         []string{""},
-		"tokenizer.ggml.scores":         []float32{0},
-		"tokenizer.ggml.token_type":     []int32{0},
-	}, []*ggml.Tensor{
-		{Name: "token_embd.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.attn_norm.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.ffn_down.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.ffn_gate.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.ffn_up.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.ffn_norm.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.attn_k.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.attn_output.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.attn_q.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "blk.0.attn_v.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-		{Name: "output.weight", Shape: []uint64{1}, WriterTo: bytes.NewReader(make([]byte, 4))},
-	})
-
-	// Use the gemma4 builtin parser — it reports HasThinkingSupport=true, which
-	// adds CapabilityThinking to the model and previously triggered deferral of
-	// the format even when the user passed think=false.
-	w := createRequest(t, s.CreateHandler, api.CreateRequest{
-		Model:    "test-gemma4-parser",
-		Files:    map[string]string{"file.gguf": digest},
-		Parser:   "gemma4",
-		Template: `{{- range .Messages }}{{ .Role }}: {{ .Content }}{{ end }}`,
-		Stream:   &stream,
-	})
-	if w.Code != http.StatusOK {
-		t.Fatalf("create: expected status 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	format := json.RawMessage(`{"type":"object","properties":{"answer":{"type":"string"}},"required":["answer"]}`)
-
-	var (
-		requestsMu sync.Mutex
-		requests   []llm.CompletionRequest
-	)
-	mock.CompletionFn = func(ctx context.Context, r llm.CompletionRequest, fn func(r llm.CompletionResponse)) error {
-		requestsMu.Lock()
-		requests = append(requests, r)
-		requestsMu.Unlock()
-
-		fn(llm.CompletionResponse{
-			Content:            `{"answer":"42"}`,
-			Done:               true,
-			DoneReason:         llm.DoneReasonStop,
-			PromptEvalCount:    1,
-			PromptEvalDuration: 1,
-			EvalCount:          1,
-			EvalDuration:       1,
-		})
-		return nil
-	}
-
-	streamRequest := false
-	think := false
-	w = createRequest(t, s.ChatHandler, api.ChatRequest{
-		Model:    "test-gemma4-parser",
-		Messages: []api.Message{{Role: "user", Content: "Respond in JSON."}},
-		Think:    &api.ThinkValue{Value: think},
-		Stream:   &streamRequest,
-		Format:   format,
-	})
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("chat: expected status 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	if len(requests) != 1 {
-		t.Fatalf("expected a single completion call, got %d", len(requests))
-	}
-
-	if !bytes.Equal([]byte(format), []byte(requests[0].Format)) {
-		t.Errorf("expected first completion format to match the request format, got %q", string(requests[0].Format))
-	}
-}
-
 func TestGenerateUnload(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 

x/imagegen/server.go

@@ -115,7 +115,36 @@ func (s *Server) Load(ctx context.Context, _ ml.SystemInfo, gpus []ml.DeviceInfo
 	// Spawn subprocess: ollama runner --imagegen-engine --model <path> --port <port>
 	cmd := exec.Command(exe, "runner", "--imagegen-engine", "--model", s.modelName, "--port", strconv.Itoa(port))
 	cmd.Env = os.Environ()
-	configureMLXSubprocessEnv(cmd, ml.LibraryPaths(gpus))
+
+	// On Linux, set LD_LIBRARY_PATH to include MLX library directories
+	if runtime.GOOS == "linux" {
+		// Build library paths: start with LibOllamaPath, then add any mlx_* subdirectories
+		libraryPaths := []string{ml.LibOllamaPath}
+		if mlxDirs, err := filepath.Glob(filepath.Join(ml.LibOllamaPath, "mlx_*")); err == nil {
+			libraryPaths = append(libraryPaths, mlxDirs...)
+		}
+
+		// Append existing LD_LIBRARY_PATH if set
+		if existingPath, ok := os.LookupEnv("LD_LIBRARY_PATH"); ok {
+			libraryPaths = append(libraryPaths, filepath.SplitList(existingPath)...)
+		}
+
+		pathEnvVal := strings.Join(libraryPaths, string(filepath.ListSeparator))
+
+		// Update or add LD_LIBRARY_PATH in cmd.Env
+		found := false
+		for i := range cmd.Env {
+			if strings.HasPrefix(cmd.Env[i], "LD_LIBRARY_PATH=") {
+				cmd.Env[i] = "LD_LIBRARY_PATH=" + pathEnvVal
+				found = true
+				break
+			}
+		}
+		if !found {
+			cmd.Env = append(cmd.Env, "LD_LIBRARY_PATH="+pathEnvVal)
+		}
+		slog.Debug("mlx subprocess library path", "LD_LIBRARY_PATH", pathEnvVal)
+	}
 
 	s.cmd = cmd
 
@@ -171,53 +200,6 @@ func (s *Server) Ping(ctx context.Context) error {
 	return nil
 }
 
-func mlxLibraryPathEnv() string {
-	switch runtime.GOOS {
-	case "windows":
-		return "PATH"
-	case "darwin":
-		return "DYLD_LIBRARY_PATH"
-	default:
-		return "LD_LIBRARY_PATH"
-	}
-}
-
-func configureMLXSubprocessEnv(cmd *exec.Cmd, libraryPaths []string) {
-	if len(libraryPaths) == 0 {
-		return
-	}
-
-	// Search order for the imagegen runner is:
-	//   1. bundled lib/ollama root
-	//   2. backend-specific library dirs selected during GPU discovery
-	//   3. any existing caller-provided library path values
-	pathEnv := mlxLibraryPathEnv()
-	pathEnvPaths := append([]string{}, libraryPaths...)
-	if existingPath, ok := os.LookupEnv(pathEnv); ok {
-		pathEnvPaths = append(pathEnvPaths, filepath.SplitList(existingPath)...)
-	}
-	setSubprocessEnv(cmd, pathEnv, strings.Join(pathEnvPaths, string(filepath.ListSeparator)))
-	slog.Debug("mlx subprocess library path", pathEnv, strings.Join(pathEnvPaths, string(filepath.ListSeparator)))
-
-	ollamaLibraryPaths := append([]string{}, libraryPaths...)
-	if existingPath, ok := os.LookupEnv("OLLAMA_LIBRARY_PATH"); ok {
-		ollamaLibraryPaths = append(ollamaLibraryPaths, filepath.SplitList(existingPath)...)
-	}
-	setSubprocessEnv(cmd, "OLLAMA_LIBRARY_PATH", strings.Join(ollamaLibraryPaths, string(filepath.ListSeparator)))
-	slog.Debug("mlx subprocess library path", "OLLAMA_LIBRARY_PATH", strings.Join(ollamaLibraryPaths, string(filepath.ListSeparator)))
-}
-
-func setSubprocessEnv(cmd *exec.Cmd, key, value string) {
-	for i := range cmd.Env {
-		name, _, ok := strings.Cut(cmd.Env[i], "=")
-		if ok && strings.EqualFold(name, key) {
-			cmd.Env[i] = key + "=" + value
-			return
-		}
-	}
-	cmd.Env = append(cmd.Env, key+"="+value)
-}
-
 // getLastErr returns the last stderr line.
 func (s *Server) getLastErr() string {
 	s.lastErrLock.Lock()

x/mlxrunner/cache/cache.go

@@ -337,10 +337,9 @@ func (c *RotatingKVCache) State() []*mlx.Array {
 	if c.keys == nil || c.values == nil {
 		return nil
 	}
-	liveLen := min(c.offset, c.keys.Dim(2))
 	return []*mlx.Array{
-		c.keys.Slice(mlx.Slice(), mlx.Slice(), mlx.Slice(0, liveLen), mlx.Slice()),
-		c.values.Slice(mlx.Slice(), mlx.Slice(), mlx.Slice(0, liveLen), mlx.Slice()),
+		c.keys.Slice(mlx.Slice(), mlx.Slice(), mlx.Slice(0, c.offset), mlx.Slice()),
+		c.values.Slice(mlx.Slice(), mlx.Slice(), mlx.Slice(0, c.offset), mlx.Slice()),
 	}
 }
 

x/mlxrunner/client.go

@@ -151,11 +151,20 @@ func (c *Client) WaitUntilRunning(ctx context.Context) error {
 	}
 }
 
-type CompletionRequest struct {
-	Prompt      string
-	Options     api.Options
-	Logprobs    bool
-	TopLogprobs int
+// completionRequest is a properly-tagged version of llm.CompletionRequest for JSON serialization.
+type completionRequest struct {
+	Prompt  string          `json:"prompt"`
+	Options *completionOpts `json:"options,omitempty"`
+}
+
+type completionOpts struct {
+	Temperature     float32 `json:"temperature,omitempty"`
+	TopP            float32 `json:"top_p,omitempty"`
+	MinP            float32 `json:"min_p,omitempty"`
+	TopK            int     `json:"top_k,omitempty"`
+	RepeatLastN     int     `json:"repeat_last_n,omitempty"`
+	PresencePenalty float32 `json:"presence_penalty,omitempty"`
+	NumPredict      int     `json:"num_predict,omitempty"`
 }
 
 type CompletionResponse struct {
@@ -168,8 +177,6 @@ type CompletionResponse struct {
 	EvalCount          int
 	EvalDuration       time.Duration
 
-	Logprobs []llm.Logprob
-
 	Error *api.StatusError
 }
 
@@ -194,13 +201,19 @@ func (c *Client) Close() error {
 
 // Completion implements llm.LlamaServer.
 func (c *Client) Completion(ctx context.Context, req llm.CompletionRequest, fn func(llm.CompletionResponse)) error {
-	creq := CompletionRequest{
-		Prompt:      req.Prompt,
-		Logprobs:    req.Logprobs,
-		TopLogprobs: req.TopLogprobs,
+	creq := completionRequest{
+		Prompt: req.Prompt,
 	}
 	if req.Options != nil {
-		creq.Options = *req.Options
+		creq.Options = &completionOpts{
+			Temperature:     req.Options.Temperature,
+			TopP:            req.Options.TopP,
+			MinP:            req.Options.MinP,
+			TopK:            req.Options.TopK,
+			RepeatLastN:     req.Options.RepeatLastN,
+			PresencePenalty: req.Options.PresencePenalty,
+			NumPredict:      req.Options.NumPredict,
+		}
 	}
 
 	body, err := json.Marshal(creq)
@@ -226,7 +239,7 @@ func (c *Client) Completion(ctx context.Context, req llm.CompletionRequest, fn f
 
 	if resp.StatusCode != http.StatusOK {
 		respBody, _ := io.ReadAll(resp.Body)
-		return api.StatusError{StatusCode: resp.StatusCode, ErrorMessage: strings.TrimSpace(string(respBody))}
+		return fmt.Errorf("%s", strings.TrimSpace(string(respBody)))
 	}
 
 	scanner := bufio.NewScanner(resp.Body)
@@ -249,7 +262,6 @@ func (c *Client) Completion(ctx context.Context, req llm.CompletionRequest, fn f
 			PromptEvalDuration: raw.PromptEvalDuration,
 			EvalCount:          raw.EvalCount,
 			EvalDuration:       raw.EvalDuration,
-			Logprobs:           raw.Logprobs,
 		}
 
 		fn(cresp)

x/mlxrunner/mlx/act.go

@@ -62,25 +62,3 @@ var LogitSoftcap = Compile2(
 	},
 	Shapeless(),
 )
-
-// sigmoidRouterFused traces the DeepSeek-V2 / GLM-MoE aux-loss-free router
-// head. Two outputs are returned so the pre-bias sigmoid (used to gather
-// per-expert scores after top-k) and the post-bias negation (used as the
-// argpartition key for top-k) share a single kernel.
-var sigmoidRouterFused = Compile(
-	"SigmoidRouter",
-	func(in ...*Array) []*Array {
-		gates, bias := in[0], in[1]
-		orig := gates.Sigmoid()
-		neg := orig.Add(bias).Negative()
-		return []*Array{orig, neg}
-	},
-	Shapeless(),
-)
-
-// SigmoidRouter returns (sigmoid(gates), -(sigmoid(gates)+bias)) as a fused
-// kernel — the DeepSeek-V2 / GLM-MoE aux-loss-free router head.
-func SigmoidRouter(gates, bias *Array) (origScores, negScores *Array) {
-	out := sigmoidRouterFused(gates, bias)
-	return out[0], out[1]
-}

x/mlxrunner/mlx/array.go

@@ -10,8 +10,6 @@ import (
 	"reflect"
 	"sort"
 	"strings"
-	"sync"
-	"sync/atomic"
 	"unsafe"
 
 	"github.com/ollama/ollama/logutil"
@@ -20,28 +18,20 @@ import (
 type Array struct {
 	ctx    C.mlx_array
 	name   string
-	pinned atomic.Int32
+	pinned int
 }
 
-var (
-	arrays   []*Array
-	arraysMu sync.Mutex
-)
+var arrays []*Array
 
 // constructor utilities
 
 func New(name string) *Array {
 	t := &Array{name: name}
-
 	if tracing {
 		traceScratch = append(traceScratch, t)
 	} else {
-		arraysMu.Lock()
-		defer arraysMu.Unlock()
-
 		arrays = append(arrays, t)
 	}
-
 	return t
 }
 
@@ -141,7 +131,7 @@ func (t *Array) Clone() *Array {
 func Pin(s ...*Array) {
 	for _, t := range s {
 		if t != nil {
-			t.pinned.Add(1)
+			t.pinned++
 		}
 	}
 }
@@ -150,7 +140,8 @@ func Pin(s ...*Array) {
 func Unpin(s ...*Array) {
 	for _, t := range s {
 		if t != nil {
-			if t.pinned.Add(-1) < 0 {
+			t.pinned--
+			if t.pinned < 0 {
 				panic(fmt.Sprintf("mlx.Unpin: negative pin count on array %q", t.name))
 			}
 		}
@@ -160,11 +151,9 @@ func Unpin(s ...*Array) {
 // Sweep releases all unpinned arrays, primarily intermediate tensors. MLX will truly
 // free them when there are no other references, including dependencies in the graph.
 func Sweep() {
-	arraysMu.Lock()
-	defer arraysMu.Unlock()
 	n := 0
 	for _, t := range arrays {
-		if t.pinned.Load() > 0 && t.Valid() {
+		if t.pinned > 0 && t.Valid() {
 			arrays[n] = t
 			n++
 		} else if t.Valid() {
@@ -191,7 +180,7 @@ func (t *Array) String() string {
 func (t *Array) LogValue() slog.Value {
 	attrs := []slog.Attr{
 		slog.String("name", t.name),
-		slog.Int("pinned", int(t.pinned.Load())),
+		slog.Int("pinned", t.pinned),
 	}
 	if t.Valid() {
 		attrs = append(attrs,
@@ -205,19 +194,19 @@ func (t *Array) LogValue() slog.Value {
 
 // shape utilities
 
-func (t *Array) Size() int {
+func (t Array) Size() int {
 	return int(C.mlx_array_size(t.ctx))
 }
 
-func (t *Array) NumBytes() int {
+func (t Array) NumBytes() int {
 	return int(C.mlx_array_nbytes(t.ctx))
 }
 
-func (t *Array) NumDims() int {
+func (t Array) NumDims() int {
 	return int(C.mlx_array_ndim(t.ctx))
 }
 
-func (t *Array) Dims() []int {
+func (t Array) Dims() []int {
 	dims := make([]int, t.NumDims())
 	for i := range dims {
 		dims[i] = t.Dim(i)
@@ -226,32 +215,29 @@ func (t *Array) Dims() []int {
 	return dims
 }
 
-func (t *Array) Dim(dim int) int {
+func (t Array) Dim(dim int) int {
 	return int(C.mlx_array_dim(t.ctx, C.int(dim)))
 }
 
-func (t *Array) DType() DType {
+func (t Array) DType() DType {
 	return DType(C.mlx_array_dtype(t.ctx))
 }
 
 // data utilities
 
-func (t *Array) Int() int {
+func (t Array) Int() int {
 	var item C.int64_t
 	C.mlx_array_item_int64(&item, t.ctx)
 	return int(item)
 }
 
-func (t *Array) Float() float64 {
+func (t Array) Float() float64 {
 	var item C.double
 	C.mlx_array_item_float64(&item, t.ctx)
 	return float64(item)
 }
 
-func (t *Array) Ints() []int {
-	if dt := t.DType(); dt != DTypeInt32 {
-		panic(fmt.Sprintf("mlx: Ints requires DTypeInt32, got %v", dt))
-	}
+func (t Array) Ints() []int {
 	ints := make([]int, t.Size())
 	for i, f := range unsafe.Slice(C.mlx_array_data_int32(t.ctx), len(ints)) {
 		ints[i] = int(f)
@@ -259,10 +245,7 @@ func (t *Array) Ints() []int {
 	return ints
 }
 
-func (t *Array) Floats() []float32 {
-	if dt := t.DType(); dt != DTypeFloat32 {
-		panic(fmt.Sprintf("mlx: Floats requires DTypeFloat32, got %v", dt))
-	}
+func (t Array) Floats() []float32 {
 	floats := make([]float32, t.Size())
 	for i, f := range unsafe.Slice(C.mlx_array_data_float32(t.ctx), len(floats)) {
 		floats[i] = float32(f)
@@ -270,7 +253,7 @@ func (t *Array) Floats() []float32 {
 	return floats
 }
 
-func (t *Array) Save(name string) error {
+func (t Array) Save(name string) error {
 	cName := C.CString(name)
 	defer C.free(unsafe.Pointer(cName))
 	C.mlx_save(cName, t.ctx)
@@ -279,8 +262,6 @@ func (t *Array) Save(name string) error {
 
 // LogArrays logs all live arrays, sorted by size
 func LogArrays() {
-	arraysMu.Lock()
-	defer arraysMu.Unlock()
 	sort.Slice(arrays, func(i, j int) bool {
 		return arrays[i].NumBytes() > arrays[j].NumBytes()
 	})
@@ -289,7 +270,7 @@ func LogArrays() {
 	for _, t := range arrays {
 		nb := t.NumBytes()
 		total += nb
-		logutil.Trace(fmt.Sprintf("tensor %-60s %5s %5s pinned=%d %v", t.name, t.DType(), PrettyBytes(nb), t.pinned.Load(), t.Dims()))
+		logutil.Trace(fmt.Sprintf("tensor %-60s %5s %5s pinned=%d %v", t.name, t.DType(), PrettyBytes(nb), t.pinned, t.Dims()))
 	}
 	logutil.Trace(fmt.Sprintf("tensors total: %d, size: %s, active: %s", len(arrays), PrettyBytes(total), PrettyBytes(ActiveMemory())))
 }

x/mlxrunner/mlx/compile.go

@@ -150,7 +150,7 @@ func closureCallback(res *C.mlx_vector_array, input C.mlx_vector_array, payload
 	traceScratch = nil
 	defer func() {
 		for _, a := range traceScratch {
-			if a.pinned.Load() > 0 {
+			if a.pinned > 0 {
 				panic("mlx: traced array was pinned during compilation")
 			}
 			if a.Valid() {

x/mlxrunner/mlx/fast.go

@@ -24,8 +24,8 @@ func ScaledDotProductAttention(query, key, value, mask *Array, scale float32) *A
 }
 
 type LayerNorm struct {
-	Weight *Array `weight:"weight"`
-	Bias   *Array `weight:"bias"`
+	Weight Array `weight:"weight"`
+	Bias   Array `weight:"bias"`
 }
 
 func (r *LayerNorm) Forward(x *Array, eps float32) *Array {
@@ -35,10 +35,10 @@ func (r *LayerNorm) Forward(x *Array, eps float32) *Array {
 }
 
 type RMSNorm struct {
-	Weight *Array `weight:"weight"`
+	Weight Array `weight:"weight"`
 }
 
-func (r *RMSNorm) Forward(x *Array, eps float32) *Array {
+func (r RMSNorm) Forward(x *Array, eps float32) *Array {
 	out := New("FAST_RMSNORM")
 	C.mlx_fast_rms_norm(&out.ctx, x.ctx, r.Weight.ctx, C.float(eps), DefaultStream().ctx)
 	return out

x/mlxrunner/mlx/nn.go

@@ -1,12 +1,12 @@
 package mlx
 
 type Linear struct {
-	Weight *Array `weight:"weight"`
-	Bias   *Array `weight:"bias"`
+	Weight Array `weight:"weight"`
+	Bias   Array `weight:"bias"`
 }
 
 // Forward computes the linear transformation: x @ Weight.T + Bias
-func (m *Linear) Forward(x *Array) *Array {
+func (m Linear) Forward(x *Array) *Array {
 	w := m.Weight.Transpose(1, 0)
 	if m.Bias.Valid() {
 		return m.Bias.Addmm(x, w, 1.0, 1.0)
@@ -15,14 +15,14 @@ func (m *Linear) Forward(x *Array) *Array {
 	return x.Matmul(w)
 }
 
-func (m *Linear) Gather(x, lhs, rhs *Array, sorted bool) *Array {
+func (m Linear) Gather(x, lhs, rhs *Array, sorted bool) *Array {
 	w := m.Weight.Transpose(0, 2, 1)
 	// TODO: bias
 	return x.GatherMM(w, lhs, rhs, sorted)
 }
 
 type Embedding struct {
-	Weight *Array `weight:"weight"`
+	Weight Array `weight:"weight"`
 }
 
 func (e *Embedding) Forward(indices *Array) *Array {

x/mlxrunner/mlx/ops.go

@@ -139,12 +139,6 @@ func (t *Array) Less(other *Array) *Array {
 	return out
 }
 
-func (t *Array) MaxAxis(axis int, keepDims bool) *Array {
-	out := New("MAX_AXIS")
-	C.mlx_max_axis(&out.ctx, t.ctx, C.int(axis), C.bool(keepDims), DefaultStream().ctx)
-	return out
-}
-
 func (t *Array) Matmul(other *Array) *Array {
 	out := New("MATMUL")
 	C.mlx_matmul(&out.ctx, t.ctx, other.ctx, DefaultStream().ctx)
@@ -175,12 +169,6 @@ func (t *Array) PutAlongAxis(indices, values *Array, axis int) *Array {
 	return out
 }
 
-func (t *Array) ScatterAddAxis(indices, values *Array, axis int) *Array {
-	out := New("SCATTER_ADD_AXIS")
-	C.mlx_scatter_add_axis(&out.ctx, t.ctx, indices.ctx, values.ctx, C.int(axis), DefaultStream().ctx)
-	return out
-}
-
 func (t *Array) Reshape(axes ...int) *Array {
 	cAxes := make([]C.int, len(axes))
 	for i := range axes {

x/mlxrunner/pipeline.go

@@ -6,59 +6,36 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"sort"
+	"net/http"
 	"time"
 
-	"github.com/ollama/ollama/llm"
+	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/logutil"
 	"github.com/ollama/ollama/x/mlxrunner/mlx"
-	sampler "github.com/ollama/ollama/x/mlxrunner/sample"
-	"github.com/ollama/ollama/x/tokenizer"
 )
 
 func prefillChunkSize() int {
 	return 2 << 10
 }
 
-// Prepare tokenizes the prompt and validates it against the model's
-// context length. It is safe to call from any goroutine. On success it
-// populates request.Tokens and adjusts request.Options.NumPredict.
-func (r *Runner) Prepare(request *Request) error {
+func (r *Runner) TextGenerationPipeline(request Request) error {
 	if r.Model == nil {
 		return errors.New("model not loaded")
 	}
 
-	tokens := r.Tokenizer.Encode(request.Prompt, r.Tokenizer.AddBOS())
-	if len(tokens) == 0 {
-		return errors.New("empty prompt")
-	}
-
-	if len(tokens) >= r.contextLength {
-		return fmt.Errorf("input length (%d tokens) exceeds the model's maximum context length (%d tokens)", len(tokens), r.contextLength)
-	}
-
-	// Cap generation to stay within the model's context length
-	maxGenerate := r.contextLength - len(tokens)
-	if request.Options.NumPredict <= 0 {
-		request.Options.NumPredict = maxGenerate
-	} else {
-		request.Options.NumPredict = min(request.Options.NumPredict, maxGenerate)
-	}
-
-	request.Tokens = tokens
-	return nil
-}
-
-func (r *Runner) TextGenerationPipeline(ctx context.Context, request Request) error {
 	mlx.ResetPeakMemory()
-	var sample, nextSample sampler.Result
+	ctx := request.Ctx
+	var (
+		sample, logprobs         *mlx.Array
+		nextSample, nextLogprobs *mlx.Array
+	)
 
 	defer func() {
 		if request.Sampler != nil {
 			request.Sampler.Free()
 		}
-		mlx.Unpin(sample.Arrays()...)
-		mlx.Unpin(nextSample.Arrays()...)
+		mlx.Unpin(sample, logprobs)
+		mlx.Unpin(nextSample, nextLogprobs)
 		mlx.Sweep()
 		mlx.ClearCache()
 
@@ -69,7 +46,26 @@ func (r *Runner) TextGenerationPipeline(ctx context.Context, request Request) er
 		slog.Info("peak memory", "size", mlx.PrettyBytes(mlx.PeakMemory()))
 	}()
 
-	inputs := request.Tokens
+	inputs := r.Tokenizer.Encode(request.Prompt, r.Tokenizer.AddBOS())
+	if len(inputs) == 0 {
+		return errors.New("empty prompt")
+	}
+
+	if len(inputs) >= r.contextLength {
+		return api.StatusError{
+			StatusCode:   http.StatusBadRequest,
+			ErrorMessage: fmt.Sprintf("input length (%d tokens) exceeds the model's maximum context length (%d tokens)", len(inputs), r.contextLength),
+		}
+	}
+
+	// Cap generation to stay within the model's context length
+	maxGenerate := r.contextLength - len(inputs)
+	if request.Options.MaxTokens <= 0 {
+		request.Options.MaxTokens = maxGenerate
+	} else {
+		request.Options.MaxTokens = min(request.Options.MaxTokens, maxGenerate)
+	}
+
 	request.Sampler.ResetHistory(inputs)
 
 	session := r.cache.begin(r.Model, inputs)
@@ -139,38 +135,41 @@ func (r *Runner) TextGenerationPipeline(ctx context.Context, request Request) er
 		mlx.ClearCache()
 	}
 
-	step := func(token *mlx.Array) sampler.Result {
+	step := func(token *mlx.Array) (*mlx.Array, *mlx.Array) {
 		fwd := r.Model.Forward(token.ExpandDims(0), caches)
 		logits := r.Model.Unembed(fwd)
 		logits = logits.Slice(mlx.Slice(), mlx.Slice(logits.Dim(1)-1), mlx.Slice()).Squeeze(1)
 
-		sample := request.Sampler.Sample(logits)
-		mlx.Pin(sample.Arrays()...)
+		logprobs := logits.Subtract(logits.Logsumexp(true))
+		sample := request.Sampler.Sample(logprobs)
+
+		mlx.Pin(sample, logprobs)
 		mlx.Sweep()
-		mlx.AsyncEval(sample.Arrays()...)
-		return sample
+		mlx.AsyncEval(sample, logprobs)
+
+		return sample, logprobs
 	}
 
-	sample = step(mlx.FromValues(tokens[processed:], total-processed))
+	sample, logprobs = step(mlx.FromValues(tokens[processed:], total-processed))
 
-	dec := decoder{tokenizer: r.Tokenizer}
+	var b bytes.Buffer
 
-	final := CompletionResponse{Done: true, PromptEvalCount: len(inputs), EvalCount: request.Options.NumPredict, DoneReason: 1}
-	for i := range request.Options.NumPredict {
+	final := CompletionResponse{Done: true, PromptEvalCount: len(inputs), EvalCount: request.Options.MaxTokens, DoneReason: 1}
+	for i := range request.Options.MaxTokens {
 		if err := ctx.Err(); err != nil {
 			return err
 		}
 
-		request.Sampler.AppendToken(sample.Token)
-		nextSample = step(sample.Token)
+		request.Sampler.AppendToken(sample)
+		nextSample, nextLogprobs = step(sample)
 
 		if i == 0 {
-			mlx.Eval(sample.Arrays()...)
+			mlx.Eval(sample)
 			final.PromptEvalDuration = time.Since(now)
 			now = time.Now()
 		}
 
-		output := int32(sample.Token.Int())
+		output := int32(sample.Int())
 		session.outputs = append(session.outputs, output)
 
 		if r.Tokenizer.IsEOS(output) {
@@ -179,16 +178,17 @@ func (r *Runner) TextGenerationPipeline(ctx context.Context, request Request) er
 			break
 		}
 
-		if resp, ok := dec.decode(sample); ok {
-			select {
-			case <-ctx.Done():
-				return ctx.Err()
-			case request.Responses <- resp:
-			}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case request.Responses <- CompletionResponse{
+			Content: r.Decode(output, &b),
+		}:
 		}
 
-		mlx.Unpin(sample.Arrays()...)
-		sample, nextSample = nextSample, sampler.Result{}
+		mlx.Unpin(sample, logprobs)
+		sample, logprobs = nextSample, nextLogprobs
+		nextSample, nextLogprobs = nil, nil
 
 		if i%256 == 0 {
 			mlx.ClearCache()
@@ -204,57 +204,13 @@ func (r *Runner) TextGenerationPipeline(ctx context.Context, request Request) er
 	}
 }
 
-// decoder serializes sampled tokens into response chunks, holding bytes
-// whose UTF-8 sequence hasn't completed yet and the logprobs that belong
-// with those bytes so Content and Logprobs stay aligned when a chunk does
-// flush.
-type decoder struct {
-	tokenizer *tokenizer.Tokenizer
-	buf       bytes.Buffer
-	logprobs  []llm.Logprob
-}
-
-func (d *decoder) decode(res sampler.Result) (CompletionResponse, bool) {
-	output := int32(res.Token.Int())
-	d.buf.WriteString(d.tokenizer.Decode([]int32{output}))
-	d.logprobs = append(d.logprobs, buildLogprob(res, d.tokenizer.Decode)...)
-
-	content := flushValidUTF8Prefix(&d.buf)
-	if content == "" {
-		return CompletionResponse{}, false
-	}
-	resp := CompletionResponse{Content: content, Logprobs: d.logprobs}
-	d.logprobs = nil
-	return resp, true
-}
-
-func buildLogprob(sample sampler.Result, decode func([]int32) string) []llm.Logprob {
-	if sample.Logprob == nil {
-		return nil
-	}
-	tok := func(id int32) string { return decode([]int32{id}) }
-
-	out := llm.Logprob{
-		TokenLogprob: llm.TokenLogprob{
-			Token:   tok(int32(sample.Token.Int())),
-			Logprob: float64(sample.Logprob.Floats()[0]),
-		},
-	}
-
-	if sample.TopTokens != nil {
-		ids := sample.TopTokens.Ints()
-		vals := sample.TopLogprobs.Floats()
-		pairs := make([]llm.TokenLogprob, len(ids))
-		for i, id := range ids {
-			pairs[i] = llm.TokenLogprob{
-				Token:   tok(int32(id)),
-				Logprob: float64(vals[i]),
-			}
-		}
-		sort.Slice(pairs, func(i, j int) bool {
-			return pairs[i].Logprob > pairs[j].Logprob
-		})
-		out.TopLogprobs = pairs
-	}
-	return []llm.Logprob{out}
+func (r Runner) Decode(sample int32, b *bytes.Buffer) string {
+	token := r.Tokenizer.Decode([]int32{sample})
+
+	if _, err := b.WriteString(token); err != nil {
+		slog.Error("Failed to write token to buffer", "error", err)
+		return ""
+	}
+
+	return flushValidUTF8Prefix(b)
 }

x/mlxrunner/runner.go

@@ -18,20 +18,32 @@ import (
 	"github.com/ollama/ollama/x/tokenizer"
 )
 
-// Request is a short-lived struct that carries a completion request through
-// a channel from the HTTP handler to the runner goroutine. The ctx field
-// must travel with the request so that cancellation propagates across the
-// channel boundary.
 type Request struct {
-	CompletionRequest
+	TextCompletionsRequest
 	Responses chan CompletionResponse
-	Pipeline  func(context.Context, Request) error
+	Pipeline  func(Request) error
+
+	Ctx context.Context
 
-	Ctx     context.Context //nolint:containedctx
-	Tokens  []int32
 	Sampler *sample.Sampler
 }
 
+type TextCompletionsRequest struct {
+	Prompt  string `json:"prompt"`
+	Options struct {
+		Temperature     float32 `json:"temperature"`
+		TopP            float32 `json:"top_p"`
+		MinP            float32 `json:"min_p"`
+		TopK            int     `json:"top_k"`
+		RepeatLastN     int     `json:"repeat_last_n"`
+		PresencePenalty float32 `json:"presence_penalty"`
+		MaxTokens       int     `json:"max_tokens"`
+
+		// Deprecated: use MaxTokens instead
+		NumPredict int `json:"num_predict"`
+	} `json:"options"`
+}
+
 type Runner struct {
 	Model         base.Model
 	Tokenizer     *tokenizer.Tokenizer
@@ -135,7 +147,7 @@ func (r *Runner) Run(host, port string, mux http.Handler) error {
 			case <-ctx.Done():
 				return nil
 			case request := <-r.Requests:
-				if err := request.Pipeline(request.Ctx, request); err != nil {
+				if err := request.Pipeline(request); err != nil {
 					slog.Info("Request terminated", "error", err)
 					var statusErr api.StatusError
 					if !errors.As(err, &statusErr) {

x/mlxrunner/sample/logprob_test.go

@@ -1,249 +0,0 @@
-//go:build mlx
-
-package sample
-
-import (
-	"math"
-	"sort"
-	"testing"
-
-	"github.com/ollama/ollama/x/mlxrunner/mlx"
-)
-
-// logprobEntry is the (token id, logprob) pair returned by the sampler's
-// top-K extraction, used after the test-side descending sort.
-type logprobEntry struct {
-	id      int
-	logprob float64
-}
-
-// runSampleLogprobs drives Sample on a fresh Sampler configured for logprobs
-// and returns the greedily-sampled token id, its logprob, and the top-K
-// entries sorted descending by logprob. Logits must be a [vocab]-shaped
-// slice; the helper reshapes it to [1, vocab] before calling the sampler.
-func runSampleLogprobs(t *testing.T, logits []float32, topK int) (int, float64, []logprobEntry) {
-	t.Helper()
-
-	s := New(Options{Logprobs: true, TopLogprobs: topK})
-	defer func() {
-		s.Free()
-		mlx.Sweep()
-	}()
-
-	tensor := mlx.FromValues(logits, 1, len(logits))
-	res := s.Sample(tensor)
-
-	mlx.Pin(res.Arrays()...)
-	defer mlx.Unpin(res.Arrays()...)
-	mlx.Sweep()
-	mlx.Eval(res.Arrays()...)
-
-	selected := res.Token.Int()
-	selLP := float64(res.Logprob.Floats()[0])
-
-	var top []logprobEntry
-	if topK > 0 && res.TopTokens != nil {
-		ids := res.TopTokens.Ints()
-		vals := res.TopLogprobs.Floats()
-		top = make([]logprobEntry, len(ids))
-		for i, id := range ids {
-			top[i] = logprobEntry{id: id, logprob: float64(vals[i])}
-		}
-		sort.Slice(top, func(i, j int) bool { return top[i].logprob > top[j].logprob })
-	}
-	return selected, selLP, top
-}
-
-func TestSampleLogprobsBasic(t *testing.T) {
-	tests := []struct {
-		name           string
-		logits         []float32
-		topK           int
-		wantSelectedID int
-		wantTopLen     int
-	}{
-		{
-			name:           "single token without top logprobs",
-			logits:         []float32{1.0, 0.5, 0.3, 0.1},
-			topK:           0,
-			wantSelectedID: 0,
-			wantTopLen:     0,
-		},
-		{
-			name:           "single token with top logprobs",
-			logits:         []float32{1.0, 0.5, 0.3, 0.1},
-			topK:           3,
-			wantSelectedID: 0,
-			wantTopLen:     3,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			selected, _, top := runSampleLogprobs(t, tt.logits, tt.topK)
-			if selected != tt.wantSelectedID {
-				t.Errorf("selected = %d, want %d", selected, tt.wantSelectedID)
-			}
-			if len(top) != tt.wantTopLen {
-				t.Errorf("top-K length = %d, want %d", len(top), tt.wantTopLen)
-			}
-		})
-	}
-}
-
-func TestSampleLogprobsNumericalStability(t *testing.T) {
-	logits := []float32{1000.0, 999.0, 998.0}
-	_, selLP, top := runSampleLogprobs(t, logits, 3)
-
-	if math.IsInf(selLP, 0) || math.IsNaN(selLP) {
-		t.Errorf("selected logprob is not finite: %f", selLP)
-	}
-	for i, e := range top {
-		if math.IsInf(e.logprob, 0) || math.IsNaN(e.logprob) {
-			t.Errorf("top[%d] logprob is not finite: %f", i, e.logprob)
-		}
-	}
-	for i := 1; i < len(top); i++ {
-		if top[i].logprob > top[i-1].logprob {
-			t.Errorf("top logprobs not descending: %f > %f", top[i].logprob, top[i-1].logprob)
-		}
-	}
-}
-
-func TestSampleLogprobsProbabilityCorrectness(t *testing.T) {
-	tests := []struct {
-		name   string
-		logits []float32
-	}{
-		{"uniform", []float32{1.0, 1.0, 1.0, 1.0}},
-		{"different", []float32{2.0, 1.0, 0.5, 0.1}},
-		{"negative", []float32{-1.0, -2.0, -3.0, -4.0}},
-		{"mixed", []float32{5.0, -5.0, 0.0, 2.5}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			selected, selLP, top := runSampleLogprobs(t, tt.logits, len(tt.logits))
-
-			if selLP > 0 {
-				t.Errorf("selected logprob should be <= 0, got %f", selLP)
-			}
-			for i, e := range top {
-				if e.logprob > 0 {
-					t.Errorf("top[%d] logprob should be <= 0, got %f", i, e.logprob)
-				}
-			}
-
-			if tt.name == "uniform" {
-				want := 1.0 / float64(len(tt.logits))
-				got := math.Exp(selLP)
-				if math.Abs(got-want) > 1e-6 {
-					t.Errorf("uniform logits: selected prob = %f, want %f", got, want)
-				}
-			}
-
-			for i := 1; i < len(top); i++ {
-				if top[i].logprob > top[i-1].logprob {
-					t.Errorf("top logprobs not descending at %d: %f > %f",
-						i, top[i].logprob, top[i-1].logprob)
-				}
-			}
-
-			found := false
-			for _, e := range top {
-				if e.id == selected {
-					found = true
-					if math.Abs(e.logprob-selLP) > 1e-6 {
-						t.Errorf("selected logprob mismatch: selLP=%f top=%f", selLP, e.logprob)
-					}
-					break
-				}
-			}
-			if !found {
-				t.Errorf("selected token %d not present in top-K", selected)
-			}
-		})
-	}
-}
-
-func TestSampleLogprobsSoftmaxCorrectness(t *testing.T) {
-	tests := []struct {
-		name   string
-		logits []float32
-	}{
-		{"small vocabulary", []float32{1.0, 2.0, 3.0}},
-		{"large differences", []float32{10.0, 0.0, -10.0}},
-		{"all equal", []float32{5.0, 5.0, 5.0, 5.0, 5.0}},
-		{"very large values", []float32{500.0, 499.0, 498.0}},
-		{"very small values", []float32{-500.0, -499.0, -498.0}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, _, top := runSampleLogprobs(t, tt.logits, len(tt.logits))
-			if len(top) != len(tt.logits) {
-				t.Fatalf("top-K length = %d, want %d", len(top), len(tt.logits))
-			}
-
-			var sum float64
-			for _, e := range top {
-				p := math.Exp(e.logprob)
-				if p < 0 || p > 1 {
-					t.Errorf("token %d: probability %f out of [0,1]", e.id, p)
-				}
-				sum += p
-			}
-
-			if math.Abs(sum-1.0) > 1e-5 {
-				t.Errorf("probabilities sum = %f, want 1.0", sum)
-			}
-		})
-	}
-}
-
-func TestSampleLogprobsSelectedTokenCorrectness(t *testing.T) {
-	logits := []float32{3.0, 1.0, 2.0, 0.5}
-
-	maxIdx := 0
-	for i, v := range logits[1:] {
-		if v > logits[maxIdx] {
-			maxIdx = i + 1
-		}
-	}
-
-	selected, selLP, top := runSampleLogprobs(t, logits, len(logits))
-
-	if selected != maxIdx {
-		t.Errorf("selected = %d, want argmax %d", selected, maxIdx)
-	}
-
-	if top[0].id != maxIdx {
-		t.Errorf("top[0].id = %d, want argmax %d", top[0].id, maxIdx)
-	}
-	if math.Abs(top[0].logprob-selLP) > 1e-6 {
-		t.Errorf("top[0].logprob = %f, want selected %f", top[0].logprob, selLP)
-	}
-}
-
-func TestSampleLogprobsTopKOrdering(t *testing.T) {
-	// Logits chosen so argmax order differs from index order.
-	logits := []float32{2.0, 5.0, 1.0, 4.0, 3.0}
-	wantOrder := []int{1, 3, 4, 0, 2}
-
-	_, _, top := runSampleLogprobs(t, logits, len(logits))
-
-	if len(top) != len(wantOrder) {
-		t.Fatalf("top-K length = %d, want %d", len(top), len(wantOrder))
-	}
-	for i, e := range top {
-		if e.id != wantOrder[i] {
-			t.Errorf("top[%d].id = %d, want %d", i, e.id, wantOrder[i])
-		}
-	}
-	for i := 1; i < len(top); i++ {
-		if top[i].logprob > top[i-1].logprob {
-			t.Errorf("top[%d].logprob (%f) > top[%d].logprob (%f)",
-				i, top[i].logprob, i-1, top[i-1].logprob)
-		}
-	}
-}

x/mlxrunner/sample/sample.go

@@ -8,76 +8,47 @@ import (
 
 type Transform func(*Sampler, *mlx.Array) *mlx.Array
 
-type Options struct {
-	Temperature      float32
-	TopP             float32
-	MinP             float32
-	TopK             int
-	RepeatLastN      int
-	RepeatPenalty    float32
-	PresencePenalty  float32
-	FrequencyPenalty float32
-
-	// Logprobs causes Sample to populate Result.Logprob with the selected
-	// token's log-probability. TopLogprobs (when > 0) adds top-K pairs.
-	Logprobs    bool
-	TopLogprobs int
-}
-
 type Sampler struct {
-	Options
+	Temperature     float32
+	TopP            float32
+	MinP            float32
+	TopK            int
+	RepeatLastN     int
+	PresencePenalty float32
 
 	history    *mlx.Array
 	historyLen int
 	transforms []Transform
 }
 
-// Result bundles the outputs of one decode step. The logprob tensors are
-// populated only when the sampler is configured to report them.
-type Result struct {
-	Token       *mlx.Array // sampled token id, shape [B]
-	Logprob     *mlx.Array // sampled-token logprob, shape [B,1]; nil unless Logprobs
-	TopTokens   *mlx.Array // top-K token ids, shape [B,K]; nil unless TopLogprobs > 0
-	TopLogprobs *mlx.Array // top-K logprobs, shape [B,K]; nil unless TopLogprobs > 0
-}
-
-// Arrays returns the tensor fields as a slice so callers can drive the mlx
-// lifecycle verbs (Pin, Unpin, Eval, AsyncEval) over the whole group. Unset
-// fields stay nil; the mlx helpers skip them.
-func (r Result) Arrays() []*mlx.Array {
-	return []*mlx.Array{r.Token, r.Logprob, r.TopTokens, r.TopLogprobs}
-}
-
-func New(opts Options) *Sampler {
-	if opts.RepeatPenalty <= 0 {
-		opts.RepeatPenalty = 1
+func New(temp, top_p, min_p float32, top_k, repeatLastN int, presencePenalty float32) *Sampler {
+	s := &Sampler{
+		Temperature:     temp,
+		TopP:            top_p,
+		MinP:            min_p,
+		TopK:            top_k,
+		RepeatLastN:     repeatLastN,
+		PresencePenalty: presencePenalty,
 	}
 
-	s := &Sampler{Options: opts}
-
 	var transforms []Transform
-	if s.usesHistory() {
+	if presencePenalty != 0 {
 		transforms = append(transforms, penalty)
 	}
 
-	hasTopP := opts.TopP > 0 && opts.TopP < 1
-	hasTopK := opts.TopK > 0
-	switch {
-	case hasTopP:
-		// topKTopP always does a full descending sort for the top-P
-		// cumulative mask and opportunistically masks top-K during the
-		// same pass when it is also configured.
-		transforms = append(transforms, topKTopP)
-	case hasTopK:
-		// Argpartition (partial sort) is cheaper than a full sort.
-		transforms = append(transforms, topK)
+	if top_p > 0 && top_p < 1 {
+		transforms = append(transforms, topP)
 	}
 
-	if opts.MinP != 0 {
+	if min_p != 0 {
 		transforms = append(transforms, minP)
 	}
 
-	if opts.Temperature == 0 {
+	if top_k > 0 {
+		transforms = append(transforms, topK)
+	}
+
+	if temp == 0 {
 		transforms = append(transforms, greedy)
 	} else {
 		transforms = append(transforms, temperature)
@@ -88,7 +59,7 @@ func New(opts Options) *Sampler {
 }
 
 func (s *Sampler) usesHistory() bool {
-	return s.RepeatPenalty != 1 || s.PresencePenalty != 0 || s.FrequencyPenalty != 0
+	return s.PresencePenalty != 0
 }
 
 func (s *Sampler) setHistory(history *mlx.Array, historyLen int) {
@@ -144,138 +115,75 @@ func (s *Sampler) Free() {
 	s.setHistory(nil, 0)
 }
 
-// Sample runs the configured transform chain on the raw per-token logits
-// and returns the sampled token id plus, when configured, the reported
-// log-probability tensors for the selected token and the top-K tokens.
-func (s *Sampler) Sample(logits *mlx.Array) Result {
-	scores := logits
+func (s *Sampler) Sample(logits *mlx.Array) *mlx.Array {
 	for _, transform := range s.transforms {
-		scores = transform(s, scores)
+		logits = transform(s, logits)
 	}
-	res := Result{Token: scores}
+	return logits
+}
 
-	if s.Logprobs {
-		// Compute log_softmax in fp32 and subtract the max before
-		// logsumexp so the final subtraction stays on small values.
-		// Otherwise it cancels two large numbers and loses precision.
-		lp := logits.AsType(mlx.DTypeFloat32)
-		lp = lp.Subtract(lp.MaxAxis(-1, true))
-		lp = lp.Subtract(lp.Logsumexp(true))
-		res.Logprob = lp.TakeAlongAxis(res.Token.ExpandDims(-1), -1)
-		if k := s.TopLogprobs; k > 0 {
-			if vocab := lp.Dim(lp.NumDims() - 1); k > vocab {
-				k = vocab
-			}
-			// Argpartition on the negated values places the K largest
-			// (unsorted) in positions [0:K].
-			idx := lp.Negative().ArgpartitionAxis(k-1, -1).Slice(mlx.Slice(), mlx.Slice(0, k))
-			res.TopTokens = idx.AsType(mlx.DTypeInt32)
-			res.TopLogprobs = lp.TakeAlongAxis(idx, -1)
-		}
+func greedy(_ *Sampler, logits *mlx.Array) *mlx.Array {
+	return logits.Argmax(-1, false)
+}
+
+func temperature(s *Sampler, logits *mlx.Array) *mlx.Array {
+	return mlx.DivScalar(logits, s.Temperature).Categorical(-1)
+}
+
+func topP(s *Sampler, logprobs *mlx.Array) *mlx.Array {
+	if s.TopP <= 0 || s.TopP >= 1 {
+		return logprobs
 	}
-	return res
-}
 
-func greedy(_ *Sampler, scores *mlx.Array) *mlx.Array {
-	return scores.Argmax(-1, false)
-}
-
-func temperature(s *Sampler, scores *mlx.Array) *mlx.Array {
-	return mlx.DivScalar(scores, s.Temperature).Categorical(-1)
-}
-
-// topKTopP applies top-P in a descending sort pass and, when top-K is also
-// configured, masks any surviving value below the K-th largest in the same
-// pass. Callers dispatch here whenever top-P is enabled — the top-K-only
-// case uses a cheaper partial sort via the topK transform.
-func topKTopP(s *Sampler, scores *mlx.Array) *mlx.Array {
-	vocab := scores.Dim(scores.NumDims() - 1)
-	applyTopK := s.TopK > 0 && s.TopK < vocab
-
-	order := scores.Negative().ArgsortAxis(-1)
-	sorted := scores.TakeAlongAxis(order, -1)
-	negInf := mlx.FromValue(float32(math.Inf(-1)))
-
-	// Top-P: in descending order, keep tokens whose exclusive cumulative
-	// probability is still below s.TopP.
-	probs := mlx.SoftmaxAxis(sorted, -1, true)
-	prevCumProbs := probs.Cumsum(-1, false, true).Subtract(probs)
+	order := logprobs.Negative().ArgsortAxis(-1)
+	sortedLogprobs := logprobs.TakeAlongAxis(order, -1)
+	sortedProbs := mlx.SoftmaxAxis(sortedLogprobs, -1, true)
+	prevCumProbs := sortedProbs.Cumsum(-1, false, true).Subtract(sortedProbs)
 	keep := prevCumProbs.Less(mlx.FromValue(s.TopP))
-	sorted = mlx.Where(keep, sorted, negInf)
-
-	out := scores.PutAlongAxis(order, sorted, -1)
-
-	// Top-K: sorted is already in descending order, so positions [K, V)
-	// are the ones to drop. Scatter -inf through their original-layout
-	// indices (order[K:]). Positional (not value-based) so exactly K
-	// tokens survive — ties at the K-th logit get broken by the sort
-	// order rather than promoted through the filter.
-	if applyTopK {
-		dropOrder := order.Slice(mlx.Slice(), mlx.Slice(s.TopK, mlx.End))
-		out = out.PutAlongAxis(dropOrder, negInf, -1)
-	}
-
-	return out
+	filtered := mlx.Where(keep, sortedLogprobs, mlx.FromValue(float32(math.Inf(-1))))
+	return logprobs.PutAlongAxis(order, filtered, -1)
 }
 
-func minP(s *Sampler, scores *mlx.Array) *mlx.Array {
+func minP(s *Sampler, logprobs *mlx.Array) *mlx.Array {
 	if s.MinP <= 0 || s.MinP > 1 {
-		return scores
+		return logprobs
 	}
 
-	maxScore := scores.MaxAxis(-1, true)
-	threshold := mlx.AddScalar(maxScore, float32(math.Log(float64(s.MinP))))
+	maxLogprobs := logprobs.TakeAlongAxis(logprobs.Argmax(-1, true), -1)
+	minLogprobs := mlx.AddScalar(maxLogprobs, float32(math.Log(float64(s.MinP))))
 
 	return mlx.Where(
-		scores.Less(threshold),
+		logprobs.Less(minLogprobs),
 		mlx.FromValue(float32(math.Inf(-1))),
-		scores,
+		logprobs,
 	)
 }
 
-func topK(s *Sampler, scores *mlx.Array) *mlx.Array {
+func topK(s *Sampler, logprobs *mlx.Array) *mlx.Array {
 	if s.TopK <= 0 {
-		return scores
+		return logprobs
 	}
 
-	vocab := scores.Dim(scores.NumDims() - 1)
+	vocab := logprobs.Dim(logprobs.NumDims() - 1)
 	if s.TopK >= vocab {
-		return scores
+		return logprobs
 	}
 
-	mask := scores.Negative().ArgpartitionAxis(s.TopK-1, -1).Slice(mlx.Slice(), mlx.Slice(s.TopK, mlx.End))
-	return scores.PutAlongAxis(mask, mlx.FromValue(float32(math.Inf(-1))), -1)
+	mask := logprobs.Negative().ArgpartitionAxis(s.TopK-1, -1).Slice(mlx.Slice(), mlx.Slice(s.TopK, mlx.End))
+	return logprobs.PutAlongAxis(mask, mlx.FromValue(float32(math.Inf(-1))), -1)
 }
 
-func penalty(s *Sampler, scores *mlx.Array) *mlx.Array {
-	if s.historyLen == 0 {
-		return scores
+func penalty(s *Sampler, logprobs *mlx.Array) *mlx.Array {
+	if s.history == nil || s.historyLen == 0 || s.PresencePenalty == 0 {
+		return logprobs
 	}
 
 	tokenIndices := s.history
-	if scores.NumDims() > 1 {
+	if logprobs.NumDims() > 1 {
 		tokenIndices = tokenIndices.ExpandDims(0)
 	}
 
-	if s.RepeatPenalty != 1 || s.PresencePenalty != 0 {
-		adjusted := scores.TakeAlongAxis(tokenIndices, -1)
-		if s.RepeatPenalty != 1 {
-			factor := mlx.Where(
-				adjusted.Less(mlx.FromValue(float32(0))),
-				mlx.FromValue(s.RepeatPenalty),
-				mlx.FromValue(1/s.RepeatPenalty),
-			)
-			adjusted = adjusted.Multiply(factor)
-		}
-		if s.PresencePenalty != 0 {
-			adjusted = mlx.AddScalar(adjusted, -s.PresencePenalty)
-		}
-		scores = scores.PutAlongAxis(tokenIndices, adjusted, -1)
-	}
-
-	if s.FrequencyPenalty != 0 {
-		scores = scores.ScatterAddAxis(tokenIndices, mlx.FromValue(-s.FrequencyPenalty), -1)
-	}
-
-	return scores
+	selected := logprobs.TakeAlongAxis(tokenIndices, -1)
+	adjusted := mlx.AddScalar(selected, -s.PresencePenalty)
+	return logprobs.PutAlongAxis(tokenIndices, adjusted, -1)
 }

x/mlxrunner/sample/sample_test.go

@@ -10,7 +10,8 @@ import (
 )
 
 func TestPresencePenaltyUsesAppendedTokenImmediately(t *testing.T) {
-	s := New(Options{RepeatLastN: 1, PresencePenalty: 6})
+	// RepeatLastN = 1, PresencePenalty = 6
+	s := New(0, 0, 0, 0, 1, 6)
 	defer func() {
 		s.Free()
 		mlx.Sweep()
@@ -19,11 +20,11 @@ func TestPresencePenaltyUsesAppendedTokenImmediately(t *testing.T) {
 	s.ResetHistory([]int32{0})
 	s.AppendToken(mlx.NewArrayInt32([]int32{1}, []int32{1}))
 
-	logits := mlx.FromValues([]float32{0, 5, 4}, 3)
-	got := s.Sample(logits).Token
+	logprobs := mlx.FromValues([]float32{0, 5, 4}, 3)
+	got := s.Sample(logprobs)
 	mlx.Eval(got)
 
-	// logits will be [0, -1, 4] after the penalty
+	// logprobs will be [0, -1, 4] after the penalty
 	// and then (index) 2 after the greedy sampler
 	gotInt := got.Int()
 	if gotInt != 2 {
@@ -31,59 +32,19 @@ func TestPresencePenaltyUsesAppendedTokenImmediately(t *testing.T) {
 	}
 }
 
-func TestRepeatPenaltyUsesHistoryWithoutPresencePenalty(t *testing.T) {
-	s := New(Options{RepeatLastN: 1, RepeatPenalty: 2})
-	defer func() {
-		s.Free()
-		mlx.Sweep()
-	}()
-
-	s.ResetHistory([]int32{1})
-
-	logits := mlx.FromValues([]float32{0, 5, 4}, 3)
-	got := s.Sample(logits).Token
-	mlx.Eval(got)
-
-	// token 1 is repeated and positive, so 5 / 2 falls below token 2.
-	gotInt := got.Int()
-	if gotInt != 2 {
-		t.Fatalf("got %d, want 2", gotInt)
-	}
-}
-
-func TestFrequencyPenaltyUsesTokenCounts(t *testing.T) {
-	s := New(Options{RepeatLastN: 4, FrequencyPenalty: 2})
-	defer func() {
-		s.Free()
-		mlx.Sweep()
-	}()
-
-	s.ResetHistory([]int32{1, 1})
-
-	logits := mlx.FromValues([]float32{0, 5, 4}, 3)
-	got := s.Sample(logits).Token
-	mlx.Eval(got)
-
-	// token 1 appears twice, so 5 - (2 * 2) falls below token 2.
-	gotInt := got.Int()
-	if gotInt != 2 {
-		t.Fatalf("got %d, want 2", gotInt)
-	}
-}
-
 func TestMinPMasksTokensBelowThreshold(t *testing.T) {
-	s := New(Options{MinP: 0.5})
+	s := New(0, 0, 0.5, 0, 0, 0)
 	defer func() {
 		s.Free()
 		mlx.Sweep()
 	}()
 
-	logits := mlx.FromValues([]float32{
+	logprobs := mlx.FromValues([]float32{
 		float32(math.Log(0.5)),
 		float32(math.Log(0.3)),
 		float32(math.Log(0.2)),
 	}, 3)
-	got := minP(s, logits)
+	got := minP(s, logprobs)
 	mlx.Eval(got)
 
 	gotFloats := got.Floats()

x/mlxrunner/server.go

@@ -2,6 +2,7 @@ package mlxrunner
 
 import (
 	"bytes"
+	"cmp"
 	"context"
 	"encoding/json"
 	"flag"
@@ -86,30 +87,23 @@ func Execute(args []string) error {
 	mux.HandleFunc("POST /v1/completions", func(w http.ResponseWriter, r *http.Request) {
 		request := Request{Responses: make(chan CompletionResponse)}
 
-		if err := json.NewDecoder(r.Body).Decode(&request.CompletionRequest); err != nil {
+		if err := json.NewDecoder(r.Body).Decode(&request.TextCompletionsRequest); err != nil {
 			slog.Error("Failed to decode request", "error", err)
 			http.Error(w, "Bad Request", http.StatusBadRequest)
 			return
 		}
 
-		request.Pipeline = runner.TextGenerationPipeline
-		request.Sampler = sample.New(sample.Options{
-			Temperature:      request.Options.Temperature,
-			TopP:             request.Options.TopP,
-			MinP:             request.Options.MinP,
-			TopK:             request.Options.TopK,
-			RepeatLastN:      request.Options.RepeatLastN,
-			RepeatPenalty:    request.Options.RepeatPenalty,
-			PresencePenalty:  request.Options.PresencePenalty,
-			FrequencyPenalty: request.Options.FrequencyPenalty,
-			Logprobs:         request.Logprobs,
-			TopLogprobs:      request.TopLogprobs,
-		})
+		request.Options.MaxTokens = cmp.Or(request.Options.MaxTokens, request.Options.NumPredict)
 
-		if err := runner.Prepare(&request); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
+		request.Pipeline = runner.TextGenerationPipeline
+		request.Sampler = sample.New(
+			request.Options.Temperature,
+			request.Options.TopP,
+			request.Options.MinP,
+			request.Options.TopK,
+			request.Options.RepeatLastN,
+			request.Options.PresencePenalty,
+		)
 
 		var cancel context.CancelFunc
 		request.Ctx, cancel = context.WithCancel(r.Context())

x/models/gemma4/gemma4.go

@@ -1061,12 +1061,14 @@ func (m *Model) Forward(tokens *mlx.Array, caches []cache.Cache) *mlx.Array {
 			}
 		}
 
-		var donorKV *sharedKVEntry
-		h, donorKV = layer.Forward(h, c, B, L, m.TextConfig, pleInput, donorEntry, smc)
+		h = layer.Forward(h, c, B, L, m.TextConfig, pleInput, donorEntry, smc)
 
 		// If this layer is a donor, store its cached KV for later shared layers.
-		if layer.IsDonor && donorKV != nil {
-			sharedKV[layer.LayerIdx] = *donorKV
+		if layer.IsDonor && c != nil {
+			state := c.State()
+			if len(state) >= 2 && state[0] != nil && state[1] != nil {
+				sharedKV[layer.LayerIdx] = sharedKVEntry{K: state[0], V: state[1], Offset: c.Offset()}
+			}
 		}
 	}
 
@@ -1188,9 +1190,9 @@ func sliceLayerDim(combined *mlx.Array, layerIdx, B, L, pleDim int32) *mlx.Array
 	return mlx.Squeeze(sliced, 2)
 }
 
-func (l *DecoderLayer) Forward(x *mlx.Array, c cache.Cache, B, L int32, cfg *TextConfig, pleInput *mlx.Array, donorEntry *sharedKVEntry, slidingMaskCache *slidingMaskCache) (*mlx.Array, *sharedKVEntry) {
+func (l *DecoderLayer) Forward(x *mlx.Array, c cache.Cache, B, L int32, cfg *TextConfig, pleInput *mlx.Array, donorEntry *sharedKVEntry, slidingMaskCache *slidingMaskCache) *mlx.Array {
 	normed := mlx.RMSNormFn(x, l.InputNormScaled, cfg.RMSNormEps)
-	attnOut, donorKV := l.Attention.Forward(normed, c, B, L, l.IsSliding, cfg, donorEntry, slidingMaskCache)
+	attnOut := l.Attention.Forward(normed, c, B, L, l.IsSliding, cfg, donorEntry, slidingMaskCache)
 	attnOut = mlx.RMSNormFn(attnOut, l.PostAttnNormScaled, cfg.RMSNormEps)
 	h := mlx.Add(x, attnOut)
 
@@ -1235,10 +1237,10 @@ func (l *DecoderLayer) Forward(x *mlx.Array, c cache.Cache, B, L int32, cfg *Tex
 		h = mlx.Mul(h, l.LayerScalar)
 	}
 
-	return h, donorKV
+	return h
 }
 
-func (a *Attention) Forward(x *mlx.Array, c cache.Cache, B, L int32, isSliding bool, cfg *TextConfig, donorEntry *sharedKVEntry, slidingMaskCache *slidingMaskCache) (*mlx.Array, *sharedKVEntry) {
+func (a *Attention) Forward(x *mlx.Array, c cache.Cache, B, L int32, isSliding bool, cfg *TextConfig, donorEntry *sharedKVEntry, slidingMaskCache *slidingMaskCache) *mlx.Array {
 	// Determine head dim and scale based on layer type.
 	headDim := cfg.HeadDim
 	scale := cfg.SlidingScale
@@ -1272,7 +1274,6 @@ func (a *Attention) Forward(x *mlx.Array, c cache.Cache, B, L int32, isSliding b
 	q = mlx.RoPEWithFreqs(q, ropeDims, false, ropeBase, 1.0, offset, ropeFreqs)
 
 	var k, v *mlx.Array
-	var donorKV *sharedKVEntry
 
 	if donorEntry != nil {
 		// Shared layer: use donor's cached K/V.
@@ -1311,7 +1312,6 @@ func (a *Attention) Forward(x *mlx.Array, c cache.Cache, B, L int32, isSliding b
 		// Update cache.
 		if c != nil {
 			k, v = c.Update(k, v)
-			donorKV = &sharedKVEntry{K: k, V: v, Offset: c.Offset()}
 		}
 	}
 
@@ -1365,7 +1365,7 @@ func (a *Attention) Forward(x *mlx.Array, c cache.Cache, B, L int32, isSliding b
 		// strided views differently. Metal handles them natively.
 		out = mlx.Contiguous(out, false)
 	}
-	return a.OProj.Forward(out), donorKV
+	return a.OProj.Forward(out)
 }
 
 func (m *MLP) Forward(x *mlx.Array) *mlx.Array {

x/models/gemma4/gemma4_moe_test.go

@@ -144,8 +144,6 @@ func TestRouterForwardMatchesLegacy(t *testing.T) {
 
 	gotScores, gotInds := r.Forward(x, cfg)
 	wantScores, wantInds := legacyRouterForward(r, x, cfg)
-	gotInds = gotInds.AsType(mlx.DTypeInt32)
-	wantInds = wantInds.AsType(mlx.DTypeInt32)
 	mlx.Eval(gotScores, gotInds, wantScores, wantInds)
 
 	if got, want := gotInds.Ints(), wantInds.Ints(); !intSlicesEqual(got, want) {

x/models/glm4_moe_lite/glm4_moe_lite.go

@@ -161,21 +161,21 @@ type MoEGate struct {
 func (g *MoEGate) Forward(x *mlx.Array, cfg *Config) (*mlx.Array, *mlx.Array) {
 	gates := g.Gate.Forward(x)
 
-	var origScores, negScores *mlx.Array
+	scores := mlx.Sigmoid(gates)
+	origScores := scores
+
 	if g.EScoreCorrectionBias != nil {
-		origScores, negScores = mlx.SigmoidRouter(gates, g.EScoreCorrectionBias)
-	} else {
-		origScores = mlx.Sigmoid(gates)
-		negScores = mlx.Neg(origScores)
+		scores = mlx.Add(scores, g.EScoreCorrectionBias)
 	}
 
 	topK := cfg.NumExpertsPerTok
+	negScores := mlx.Neg(scores)
 	inds := mlx.Argpartition(negScores, int(topK)-1, -1)
 
 	dims := inds.Dims()
 	inds = mlx.SliceStartStop(inds, []int32{0, 0, 0}, []int32{int32(dims[0]), int32(dims[1]), topK})
 
-	scores := mlx.TakeAlongAxis(origScores, inds, -1)
+	scores = mlx.TakeAlongAxis(origScores, inds, -1)
 
 	if topK > 1 && cfg.NormTopKProb {
 		sumScores := mlx.Sum(scores, -1, true)

x/models/nn/nn_test.go

@@ -169,8 +169,8 @@ func TestQuantizedLinearMXFP4MatchesDequantizedWeight(t *testing.T) {
 	dequantizedWeight := mlx.Dequantize(ql.Weight, ql.Scales, ql.QBiases, 32, 4, "mxfp4")
 	mlx.Eval(dequantizedWeight)
 
-	qOut := ql.Forward(input).AsType(mlx.DTypeFloat32)
-	dOut := NewLinear(dequantizedWeight, nil).Forward(input).AsType(mlx.DTypeFloat32)
+	qOut := ql.Forward(input)
+	dOut := NewLinear(dequantizedWeight, nil).Forward(input)
 	mlx.Eval(qOut, dOut)
 
 	got := qOut.Floats()