Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
app: claude model management (#17915)
Parth Sareen2d9622a4d497
diff --git a/app/cmd/app/app_darwin.go b/app/cmd/app/app_darwin.goindex 3cede88f8..9c4cd1e7c 100644--- a/app/cmd/app/app_darwin.go+++ b/app/cmd/app/app_darwin.go@@ -28,10 +28,12 @@ import ("unsafe""github.com/ollama/ollama/api"+ appui "github.com/ollama/ollama/app/ui""github.com/ollama/ollama/app/updater""github.com/ollama/ollama/app/version""github.com/ollama/ollama/cmd/launch""github.com/ollama/ollama/envconfig"+ "github.com/ollama/ollama/internal/modelref""github.com/ollama/ollama/internal/proxy")@@ -55,23 +57,55 @@ const (claudeProxyFailurePortConflict)+// claudeDesktopController abstracts launch's Claude Desktop profile management+// so app flows can be tested without probing a live gateway.+type claudeDesktopController interface {+ UsesOllamaGateway() bool+ ConfigureAutodiscovery() error+ SetInstalledFromDesktop(installed, restart bool) error+ RestartWithProfileChange(change func() error) error+ RestoreForShutdown(ctx context.Context) error+}+var (- isApp = updater.BundlePath != ""- appLogPath = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "app.log")- launchAgentPath = filepath.Join(os.Getenv("HOME"), "Library", "LaunchAgents", "com.ollama.ollama.plist")- claudeAppProxy *proxy.ClaudeDesktop- claudeProxyMu sync.Mutex- claudeProxyErr error- claudeProxyFail claudeProxyFailure- claudeDesktop = &launch.ClaudeDesktop{}-- claudeDesktopInstalled = launch.ClaudeDesktopInstalled- claudeProxyListenAddr = proxy.DefaultClaudeDesktopListenAddr- claudeProxyRetryWait = 750 * time.Millisecond- claudeProxyRetryPoll = 50 * time.Millisecond- claudeShutdownTimeout = 30 * time.Second+ isApp = updater.BundlePath != ""+ appLogPath = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "app.log")+ launchAgentPath = filepath.Join(os.Getenv("HOME"), "Library", "LaunchAgents", "com.ollama.ollama.plist")+ claudeAppProxy *proxy.ClaudeDesktop+ claudeProxyStartMu sync.Mutex+ claudeProxyMu sync.Mutex+ claudeCatalogMu sync.Mutex+ claudeProxyErr error+ claudeProxyFail claudeProxyFailure+ claudeDesktop claudeDesktopController = &launch.ClaudeDesktop{}++ claudeDesktopInstalled = launch.ClaudeDesktopInstalled+ claudeProxyListenAddr = proxy.DefaultClaudeDesktopListenAddr+ claudeProxyRetryWait = 750 * time.Millisecond+ claudeProxyRetryPoll = 50 * time.Millisecond+ claudeAccessRetryWait = 3 * time.Second+ claudeAccessRetryPoll = 100 * time.Millisecond+ claudeCatalogRefreshInterval = time.Minute+ claudeCatalogNow = time.Now+ claudeShutdownTimeout = 30 * time.Second+ claudeRecommendationsClient = &http.Client{Timeout: 3 * time.Second}+ claudeRecommendationsEndpoint = func() string {+ return strings.TrimRight(appui.OllamaDotCom, "/") + "/api/experimental/model-recommendations?app=claude-desktop"+ }+ claudeDownloadEndpoint = func() string {+ return claudeDesktopDownloadEndpoint(appui.OllamaDotCom)+ }+ claudeModelsLoader = loadClaudeDesktopModels+ claudeAvailableModels []proxy.ClaudeDesktopModel+ claudeModelSource string+ claudeCatalogUpdated time.Time++ claudeAccessStateResolver = currentClaudeDesktopAccessState+ claudeLocalModelsResolver = currentClaudeDesktopLocalModels)+var errClaudeDesktopAccessUnavailable = errors.New("Ollama couldn't verify the selected models. Try again")+// TODO(jmorganca): pre-create the window and pass// it to the webview instead of using the internal one//@@ -240,7 +274,13 @@ func osRun(_ func(), hasCompletedFirstRun, startHidden, showOnboarding bool, _ s}func reconcileClaudeAppProxy() error {- if !claudeDesktopInstalled() || !claudeDesktop.UsesOllamaGateway() {+ configured := claudeDesktop.UsesOllamaGateway()+ if configured || len(launch.ClaudeDesktopModels()) > 0 {+ if err := markClaudeDesktopIntegrationUsed(); err != nil {+ slog.Warn("failed to remember existing Claude Desktop connection", "error", err)+ }+ }+ if !claudeDesktopInstalled() || !configured {stopClaudeAppProxy()return nil}@@ -248,44 +288,53 @@ func reconcileClaudeAppProxy() error {}func startClaudeAppProxy() error {+ claudeProxyStartMu.Lock()+ defer claudeProxyStartMu.Unlock()claudeProxyMu.Lock()- defer claudeProxyMu.Unlock()if claudeAppProxy != nil {clearClaudeProxyFailure()+ claudeProxyMu.Unlock()return nil}+ claudeProxyMu.Unlock()if !claudeDesktopInstalled() {slog.Debug("Claude Desktop is not installed; skipping gateway")+ claudeProxyMu.Lock()clearClaudeProxyFailure()+ claudeProxyMu.Unlock()return nil}ollamaURL := envconfig.ConnectableHost()gatewayPort, err := claudeGatewayPort()if err != nil {- return setClaudeProxyFailure(fmt.Errorf("parse Claude gateway address: %w", err), claudeProxyFailureNone)+ return recordClaudeProxyFailure(fmt.Errorf("parse Claude gateway address: %w", err), claudeProxyFailureNone)}if ollamaURL.Port() == gatewayPort {- return setClaudeProxyFailure(+ return recordClaudeProxyFailure(fmt.Errorf("OLLAMA_HOST cannot use port %s because it is reserved for Claude", gatewayPort),claudeProxyFailurePortConflict,)}- ollamaClient := api.NewClient(ollamaURL, http.DefaultClient)+ availableModels, activeModels, modelSource := resolveClaudeDesktopStartupCatalog(context.Background())+ if err := ensureClaudeDesktopModelsAvailable(context.Background(), activeModels); err != nil {+ return recordClaudeProxyFailure(err, claudeProxyFailureNone)+ }gateway, err := proxy.NewClaudeDesktop(proxy.ClaudeDesktopConfig{ListenAddr: claudeProxyListenAddr,OllamaURL: ollamaURL.String(),- Model: "glm-5.2:cloud",+ Model: activeModels[0].OllamaModel,+ Models: activeModels,Logger: slog.Default(),OnCountsChanged: updateClaudeProxyMenu,- CloudModelsAvailable: func(ctx context.Context) bool {- return claudeCloudModelsAvailable(ctx, ollamaClient.CloudStatusExperimental, ollamaClient.Whoami)- },- ListLocalModels: func(ctx context.Context) ([]string, error) {- return claudeLocalModels(ctx, ollamaClient.List)+ RefreshModels: func(ctx context.Context, current []proxy.ClaudeDesktopModel) ([]proxy.ClaudeDesktopModel, error) {+ _, selected, _ := refreshClaudeDesktopCatalog(ctx, current, false)+ return selected, nil},+ ResolveAccessState: claudeAccessStateResolver,+ ListLocalModels: claudeLocalModelsResolver,})if err != nil {- return setClaudeProxyFailure(err, claudeProxyFailureNone)+ return recordClaudeProxyFailure(err, claudeProxyFailureNone)}if err := startClaudeGateway(gateway); err != nil {_ = gateway.Close(context.Background())@@ -293,13 +342,150 @@ func startClaudeAppProxy() error {if errors.Is(err, syscall.EADDRINUSE) {failure = claudeProxyFailurePortConflict}- return setClaudeProxyFailure(err, failure)+ return recordClaudeProxyFailure(err, failure)}+ claudeProxyMu.Lock()claudeAppProxy = gateway+ claudeAvailableModels = availableModels+ claudeModelSource = modelSource+ claudeCatalogUpdated = claudeCatalogNow()clearClaudeProxyFailure()+ claudeProxyMu.Unlock()return nil}+func resolveClaudeDesktopStartupCatalog(ctx context.Context) (available, selected []proxy.ClaudeDesktopModel, source string) {+ selectedNames := launch.ClaudeDesktopModels()+ if len(selectedNames) > 0 {+ localNames, err := claudeLocalModelsResolver(ctx)+ if err == nil && allClaudeDesktopModelsLocal(selectedNames, localNames) {+ selected = proxy.SelectClaudeDesktopModels(nil, selectedNames)+ return selected, selected, "user"+ }+ }+ return refreshClaudeDesktopCatalog(ctx, nil, true)+}++func allClaudeDesktopModelsLocal(selected, installed []string) bool {+ local := make(map[string]struct{}, len(installed))+ for _, name := range installed {+ local[strings.TrimSpace(name)] = struct{}{}+ }+ for _, name := range selected {+ name = strings.TrimSpace(name)+ if name == "" || modelref.HasExplicitCloudSource(name) {+ return false+ }+ if _, ok := local[name]; !ok {+ return false+ }+ }+ return true+}++func resolveClaudeDesktopCatalog(ctx context.Context) (available, selected []proxy.ClaudeDesktopModel, source string) {+ available, source = claudeModelsLoader(ctx)+ selectedNames := launch.ClaudeDesktopModels()+ selected = proxy.SelectClaudeDesktopModels(available, selectedNames)+ if len(selected) == 0 {+ selected = available+ }+ available = includeSelectedClaudeDesktopModels(available, selected)+ if len(selectedNames) > 0 {+ source = "user"+ }+ return available, selected, source+}++func refreshClaudeDesktopCatalog(ctx context.Context, current []proxy.ClaudeDesktopModel, force bool) (available, selected []proxy.ClaudeDesktopModel, source string) {+ claudeCatalogMu.Lock()+ defer claudeCatalogMu.Unlock()+ claudeProxyMu.Lock()+ previous := append([]proxy.ClaudeDesktopModel(nil), claudeAvailableModels...)+ fresh := len(claudeAvailableModels) > 0 && claudeCatalogNow().Before(claudeCatalogUpdated.Add(claudeCatalogRefreshInterval))+ if !force && fresh {+ available = append([]proxy.ClaudeDesktopModel(nil), claudeAvailableModels...)+ source = claudeModelSource+ }+ claudeProxyMu.Unlock()++ reloaded := len(available) == 0+ if reloaded {+ available, source = claudeModelsLoader(ctx)+ if source == "fallback" && len(previous) > 0 {+ available = preserveClaudeDesktopEntitlements(available, previous)+ }+ }+ selectedNames := launch.ClaudeDesktopModels()+ if len(current) > 0 {+ selectedNames = make([]string, len(current))+ for i, model := range current {+ selectedNames[i] = model.Name+ }+ }+ selected = proxy.SelectClaudeDesktopModels(available, selectedNames)+ if len(selected) == 0 {+ selected = available+ }+ available = includeSelectedClaudeDesktopModels(available, selected)+ if len(launch.ClaudeDesktopModels()) > 0 {+ source = "user"+ }++ claudeProxyMu.Lock()+ claudeAvailableModels = append([]proxy.ClaudeDesktopModel(nil), available...)+ claudeModelSource = source+ if reloaded {+ claudeCatalogUpdated = claudeCatalogNow()+ }+ claudeProxyMu.Unlock()+ return available, selected, source+}++func preserveClaudeDesktopEntitlements(fallback, previous []proxy.ClaudeDesktopModel) []proxy.ClaudeDesktopModel {+ models := proxy.UnverifyClaudeDesktopCloudEntitlements(fallback)+ known := make(map[string]proxy.ClaudeDesktopModel, len(previous)*2)+ for _, model := range previous {+ known[model.Name] = model+ known[model.OllamaModel] = model+ }+ for i, model := range models {+ if prior, ok := known[model.Name]; ok {+ models[i] = prior+ continue+ }+ if prior, ok := known[model.OllamaModel]; ok {+ models[i] = prior+ }+ }+ return models+}++func loadClaudeDesktopModels(ctx context.Context) ([]proxy.ClaudeDesktopModel, string) {+ models, err := proxy.FetchClaudeDesktopModels(ctx, claudeRecommendationsClient, claudeRecommendationsEndpoint())+ if err == nil {+ return models, "endpoint"+ }+ slog.Debug("could not fetch Claude Desktop model recommendations", "error", err)+ return proxy.UnverifyClaudeDesktopCloudEntitlements(proxy.DefaultClaudeDesktopModels()), "fallback"+}++func includeSelectedClaudeDesktopModels(available, selected []proxy.ClaudeDesktopModel) []proxy.ClaudeDesktopModel {+ models := append([]proxy.ClaudeDesktopModel(nil), available...)+ seen := make(map[string]struct{}, len(models))+ for _, model := range models {+ seen[model.Name] = struct{}{}+ }+ for _, model := range selected {+ if _, ok := seen[model.Name]; ok {+ continue+ }+ models = append(models, model)+ seen[model.Name] = struct{}{}+ }+ return models+}+func startClaudeGateway(gateway *proxy.ClaudeDesktop) error {deadline := time.Now().Add(claudeProxyRetryWait)for {@@ -311,30 +497,52 @@ func startClaudeGateway(gateway *proxy.ClaudeDesktop) error {}}-func claudeCloudModelsAvailable(+func resolveClaudeDesktopAccessState(ctx context.Context,cloudStatus func(context.Context) (*api.StatusResponse, error),whoami func(context.Context) (*api.UserResponse, error),-) bool {- ctx, cancel := context.WithTimeout(ctx, time.Second)- defer cancel()- status, err := cloudStatus(ctx)+) (proxy.ClaudeDesktopAccessState, error) {+ state := proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudUnknown,+ Account: proxy.ClaudeDesktopAccountUnknown,+ }+ statusCtx, cancel := context.WithTimeout(ctx, time.Second)+ status, err := cloudStatus(statusCtx)+ cancel()if err != nil {- slog.Debug("could not check whether Ollama cloud is enabled", "error", err)- } else if status != nil && status.Cloud.Disabled {- return false+ return state, fmt.Errorf("check whether Ollama cloud is enabled: %w", err)+ }+ if status != nil && status.Cloud.Disabled {+ state.Cloud = proxy.ClaudeDesktopCloudOff+ // Account eligibility cannot change the result while Cloud is off, so do+ // not make a remote account request from discovery or Settings.+ return state, nil}+ state.Cloud = proxy.ClaudeDesktopCloudOn- user, err := whoami(ctx)+ accountCtx, cancel := context.WithTimeout(ctx, time.Second)+ user, err := whoami(accountCtx)+ defer cancel()if err != nil {var authErr api.AuthorizationErrorif errors.As(err, &authErr) && authErr.StatusCode == http.StatusUnauthorized {- return false+ state.Account = proxy.ClaudeDesktopAccountSignedOut+ return state, nil}- slog.Debug("could not check whether cloud models are available", "error", err)- return true+ return state, fmt.Errorf("check Ollama account: %w", err)}- return user != nil && strings.TrimSpace(user.Name) != ""+ if user == nil || strings.TrimSpace(user.Name) == "" {+ state.Account = proxy.ClaudeDesktopAccountSignedOut+ return state, nil+ }+ state.Account = proxy.ClaudeDesktopAccountSignedIn+ state.Plan = strings.TrimSpace(user.Plan)+ return state, nil+}++func currentClaudeDesktopAccessState(ctx context.Context) (proxy.ClaudeDesktopAccessState, error) {+ client := api.NewClient(envconfig.ConnectableHost(), http.DefaultClient)+ return resolveClaudeDesktopAccessState(ctx, client.CloudStatusExperimental, client.Whoami)}func claudeLocalModels(@@ -350,19 +558,107 @@ func claudeLocalModels(names := make([]string, 0, len(response.Models)*2)for _, model := range response.Models {- if model.RemoteModel != "" || model.RemoteHost != "" {+ // /api/tags can include cloud placeholders. Only models with local+ // weights qualify as installed local choices for Claude Desktop.+ if model.RemoteModel != "" || model.RemoteHost != "" ||+ modelref.HasExplicitCloudSource(model.Name) || modelref.HasExplicitCloudSource(model.Model) {continue}if model.Name != "" {names = append(names, model.Name)+ if alias := strings.TrimSuffix(model.Name, ":latest"); alias != model.Name {+ names = append(names, alias)+ }}if model.Model != "" && model.Model != model.Name {names = append(names, model.Model)+ if alias := strings.TrimSuffix(model.Model, ":latest"); alias != model.Model {+ names = append(names, alias)+ }}}return names, nil}+func currentClaudeDesktopLocalModels(ctx context.Context) ([]string, error) {+ client := api.NewClient(envconfig.ConnectableHost(), http.DefaultClient)+ return claudeLocalModels(ctx, client.List)+}++func ensureClaudeDesktopModelsAvailable(ctx context.Context, models []proxy.ClaudeDesktopModel) error {+ deadline := time.Now().Add(claudeAccessRetryWait)+ for {+ state := proxy.ClaudeDesktopAccessState{}+ if hasCloudClaudeDesktopModel(models) {+ var stateErr error+ state, stateErr = claudeAccessStateResolver(ctx)+ if stateErr != nil {+ slog.Debug("could not resolve Claude model access", "error", stateErr)+ }+ }+ localNames, localErr := claudeLocalModelsResolver(ctx)+ if localErr != nil {+ slog.Debug("could not load local models for Claude", "error", localErr)+ }+ err := validateClaudeDesktopModels(models, state, localNames, localErr == nil)+ if !errors.Is(err, errClaudeDesktopAccessUnavailable) || time.Now().After(deadline) {+ return err+ }++ timer := time.NewTimer(claudeAccessRetryPoll)+ select {+ case <-ctx.Done():+ timer.Stop()+ return ctx.Err()+ case <-timer.C:+ }+ }+}++func hasCloudClaudeDesktopModel(models []proxy.ClaudeDesktopModel) bool {+ for _, model := range models {+ if model.Cloud {+ return true+ }+ }+ return false+}++func validateClaudeDesktopModels(models []proxy.ClaudeDesktopModel, state proxy.ClaudeDesktopAccessState, localNames []string, inventoryKnown bool) error {+ installed := make(map[string]struct{}, len(localNames))+ for _, name := range localNames {+ installed[name] = struct{}{}+ }++ reasons := make(map[proxy.ClaudeDesktopAccessReason]struct{})+ for _, model := range models {+ _, isInstalled := installed[model.OllamaModel]+ access := proxy.EvaluateClaudeDesktopModelAccess(model, state, isInstalled, inventoryKnown)+ if access.Availability == proxy.ClaudeDesktopAvailabilityAvailable {+ return nil+ }+ reasons[access.Reason] = struct{}{}+ }++ // Prefer the action that resolves the broadest part of the selected set.+ if _, ok := reasons[proxy.ClaudeDesktopAccessCloudOff]; ok {+ return errors.New("Cloud models are off. Choose an installed model in Ollama Settings")+ }+ if _, ok := reasons[proxy.ClaudeDesktopAccessSignInRequired]; ok {+ return errors.New("Sign in to Ollama or choose an installed model in Ollama Settings")+ }+ if _, ok := reasons[proxy.ClaudeDesktopAccessUpgradeRequired]; ok {+ return errors.New("Select another model in Settings to connect Claude")+ }+ if _, ok := reasons[proxy.ClaudeDesktopAccessModelNotInstalled]; ok {+ return errors.New("Install the selected model or choose another model in Ollama Settings")+ }+ if _, ok := reasons[proxy.ClaudeDesktopAccessVerificationUnavailable]; ok {+ return errClaudeDesktopAccessUnavailable+ }+ return errors.New("Choose at least one model in Ollama Settings")+}+func claudeGatewayPort() (string, error) {_, port, err := net.SplitHostPort(claudeProxyListenAddr)if err != nil {@@ -391,6 +687,12 @@ func setClaudeProxyFailure(err error, failure claudeProxyFailure) error {return err}+func recordClaudeProxyFailure(err error, failure claudeProxyFailure) error {+ claudeProxyMu.Lock()+ defer claudeProxyMu.Unlock()+ return setClaudeProxyFailure(err, failure)+}+func clearClaudeProxyFailure() {claudeProxyErr = nilclaudeProxyFail = claudeProxyFailureNone@@ -407,11 +709,50 @@ func SetClaudeGatewayInstalled(installed C.bool, restartClaude C.bool) C.bool {return C._Bool(true)}+//export HasUsedClaudeDesktopIntegration+func HasUsedClaudeDesktopIntegration() C.bool {+ return C._Bool(hasUsedClaudeDesktopIntegration())+}++func hasUsedClaudeDesktopIntegration() bool {+ if appStore == nil {+ return false+ }+ settings, err := appStore.Settings()+ if err != nil {+ slog.Warn("failed to read Claude Desktop integration history", "error", err)+ return false+ }+ return settings.ClaudeDesktopUsed+}++func markClaudeDesktopIntegrationUsed() error {+ if appStore == nil {+ return nil+ }+ settings, err := appStore.Settings()+ if err != nil {+ return fmt.Errorf("load settings: %w", err)+ }+ if settings.ClaudeDesktopUsed {+ return nil+ }+ settings.ClaudeDesktopUsed = true+ if err := appStore.SetSettings(settings); err != nil {+ return fmt.Errorf("save settings: %w", err)+ }+ return nil+}+func setClaudeGatewayInstalled(installed, restart bool) error {if installed && !claudeDesktopInstalled() {return errors.New("Claude Desktop is not installed")}if installed {+ // A failed first attempt must still expose Claude's Settings recovery UI.+ if err := markClaudeDesktopIntegrationUsed(); err != nil {+ return fmt.Errorf("remember Claude Desktop connection: %w", err)+ }if err := startClaudeAppProxy(); err != nil {return err}@@ -420,7 +761,10 @@ func setClaudeGatewayInstalled(installed, restart bool) error {if !claudeDesktop.UsesOllamaGateway() {stopClaudeAppProxy()}- return err+ if err != nil {+ return err+ }+ return nil}//export IsClaudeDesktopInstalled@@ -454,6 +798,16 @@ func ClaudeGatewayPortConflict() C.bool {return C._Bool(claudeGatewayPortConflict())}+//export ClaudeGatewayErrorMessage+func ClaudeGatewayErrorMessage() *C.char {+ claudeProxyMu.Lock()+ defer claudeProxyMu.Unlock()+ if claudeProxyErr == nil {+ return C.CString("")+ }+ return C.CString(claudeProxyErr.Error())+}+func claudeGatewayPortConflict() bool {claudeProxyMu.Lock()defer claudeProxyMu.Unlock()@@ -461,23 +815,98 @@ func claudeGatewayPortConflict() bool {}func getClaudeDesktopConnectionStatus() claudeDesktopStatus {+ used := hasUsedClaudeDesktopIntegration()claudeProxyMu.Lock()proxyErr := claudeProxyErr+ proxyFailure := claudeProxyFail+ gateway := claudeAppProxyclaudeProxyMu.Unlock()+ var availableModels, selectedModels []proxy.ClaudeDesktopModel+ var modelSource string+ if used {+ var current []proxy.ClaudeDesktopModel+ if gateway != nil {+ current = gateway.Models()+ }+ if len(current) > 0 && !hasCloudClaudeDesktopModel(current) {+ availableModels = current+ selectedModels = current+ modelSource = "user"+ } else {+ availableModels, selectedModels, modelSource = refreshClaudeDesktopCatalog(context.Background(), current, false)+ }+ }+ selected := make(map[string]struct{})+ for _, model := range selectedModels {+ selected[model.Name] = struct{}{}+ }+ accessState := proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudUnknown,+ Account: proxy.ClaudeDesktopAccountUnknown,+ }+ var localNames []string+ var localErr error+ if hasCloudClaudeDesktopModel(availableModels) {+ var accessErr error+ accessState, accessErr = claudeAccessStateResolver(context.Background())+ if accessErr != nil {+ slog.Debug("could not resolve Claude model access for Settings", "error", accessErr)+ }+ }+ if len(availableModels) > 0 {+ localNames, localErr = claudeLocalModelsResolver(context.Background())+ if localErr != nil {+ slog.Debug("could not load local models for Claude Settings", "error", localErr)+ }+ }+ localModels := make(map[string]struct{}, len(localNames))+ for _, name := range localNames {+ localModels[name] = struct{}{}+ }+ modelStatuses := make([]claudeDesktopModelStatus, 0, len(availableModels))+ for _, model := range availableModels {+ _, isSelected := selected[model.Name]+ name := model.Name+ if model.Cloud {+ name = model.OllamaModel+ }+ _, installed := localModels[model.OllamaModel]+ access := proxy.EvaluateClaudeDesktopModelAccess(model, accessState, installed, localErr == nil)+ modelStatuses = append(modelStatuses, claudeDesktopModelStatus{+ Name: name,+ DisplayName: name,+ Description: model.Description,+ Cloud: model.Cloud,+ Selected: isSelected,+ Availability: access.Availability,+ Reason: access.Reason,+ RequiredPlan: access.RequiredPlan,+ })+ }+ port := 0+ if portText, err := claudeGatewayPort(); err == nil {+ port, _ = strconv.Atoi(portText)+ }installed := claudeDesktopInstalled()configured := installed && claudeDesktop.UsesOllamaGateway()- return claudeDesktopConnectionStatus(installed, configured, launch.ClaudeDesktopRunning(), proxyErr)-}--func claudeDesktopConnectionStatus(installed, configured, running bool, proxyErr error) claudeDesktopStatus {- return claudeDesktopStatus{- Installed: installed,- Configured: configured,- Connected: configured && proxyErr == nil,- Running: running,- StartFailed: proxyErr != nil,+ status := claudeDesktopStatus{+ Supported: true,+ Used: used,+ Installed: installed,+ Configured: configured,+ Connected: configured && proxyErr == nil,+ Running: launch.ClaudeDesktopRunning(),+ StartFailed: proxyErr != nil,+ PortConflict: proxyFailure == claudeProxyFailurePortConflict,+ GatewayPort: port,+ ModelSource: modelSource,+ Models: modelStatuses,+ }+ if proxyErr != nil {+ status.Error = proxyErr.Error()}+ return status}func setClaudeDesktopConnection(enabled bool) error {@@ -505,10 +934,159 @@ func openClaudeDesktopApplication() error {return launch.OpenClaudeDesktop()}+func restartClaudeDesktopWithModels(names []string) error {+ if !claudeDesktopInstalled() {+ return errors.New("Claude Desktop is not installed")+ }+ if len(names) == 0 {+ return errors.New("select at least one Claude Desktop model")+ }+ if len(names) > proxy.MaxClaudeDesktopModels {+ return fmt.Errorf("Claude Desktop supports at most %d models; deselect %d and try again", proxy.MaxClaudeDesktopModels, len(names)-proxy.MaxClaudeDesktopModels)+ }+ claudeProxyMu.Lock()+ gateway := claudeAppProxy+ previousAvailable := append([]proxy.ClaudeDesktopModel(nil), claudeAvailableModels...)+ previousSource := claudeModelSource+ previousCatalogUpdated := claudeCatalogUpdated+ claudeProxyMu.Unlock()+ var current []proxy.ClaudeDesktopModel+ if gateway != nil {+ current = gateway.Models()+ }+ available, refreshedCurrent, _ := refreshClaudeDesktopCatalog(context.Background(), current, true)+ if len(current) == 0 {+ current = refreshedCurrent+ }++ localNames, localErr := claudeLocalModelsResolver(context.Background())+ if localErr != nil {+ slog.Debug("could not load local models for Claude Desktop selection", "error", localErr)+ }+ selected, err := selectKnownClaudeDesktopModels(available, current, localNames, names)+ if err != nil {+ return err+ }+ accessState, accessErr := claudeAccessStateResolver(context.Background())+ if accessErr != nil {+ slog.Debug("could not resolve Claude model access for selection", "error", accessErr)+ }+ if err := validateClaudeDesktopModels(selected, accessState, localNames, localErr == nil); err != nil {+ return err+ }++ normalized := make([]string, len(selected))+ for i, model := range selected {+ normalized[i] = model.Name+ if model.Cloud {+ normalized[i] = model.OllamaModel+ }+ }+ previousSelection := launch.ClaudeDesktopModels()+ restoreState := func() error {+ var rollbackErr error+ if gateway != nil && len(current) > 0 {+ rollbackErr = gateway.SetModels(current)+ }+ if err := launch.RestoreClaudeDesktopModels(previousSelection); err != nil {+ rollbackErr = errors.Join(rollbackErr, fmt.Errorf("restore Claude Desktop model selection: %w", err))+ }+ claudeProxyMu.Lock()+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousCatalogUpdated+ claudeProxyMu.Unlock()+ return rollbackErr+ }+ if gateway == nil || !claudeDesktop.UsesOllamaGateway() {+ if err := launch.SaveClaudeDesktopModels(normalized); err != nil {+ _ = restoreState()+ return fmt.Errorf("save Claude Desktop models: %w", err)+ }+ if err := setClaudeGatewayInstalled(true, launch.ClaudeDesktopRunning()); err != nil {+ // Profile installation can succeed even if opening Claude fails. Keep+ // the live and persisted model state aligned with that committed profile.+ if claudeDesktop.UsesOllamaGateway() {+ return err+ }+ return errors.Join(err, restoreState())+ }+ return nil+ }+ applyModelChange := func() error {+ if err := launch.SaveClaudeDesktopModels(normalized); err != nil {+ return errors.Join(fmt.Errorf("save Claude Desktop models: %w", err), restoreState())+ }+ if err := gateway.SetModels(selected); err != nil {+ return errors.Join(err, restoreState())+ }+ claudeProxyMu.Lock()+ claudeAvailableModels = includeSelectedClaudeDesktopModels(available, selected)+ claudeModelSource = "user"+ claudeProxyMu.Unlock()+ if err := claudeDesktop.ConfigureAutodiscovery(); err != nil {+ return errors.Join(err, restoreState())+ }+ return nil+ }+ if err := claudeDesktop.RestartWithProfileChange(applyModelChange); err != nil {+ return errors.Join(err, restoreState())+ }+ return nil+}++func selectKnownClaudeDesktopModels(available, current []proxy.ClaudeDesktopModel, localNames, names []string) ([]proxy.ClaudeDesktopModel, error) {+ selectable := includeSelectedClaudeDesktopModels(available, current)+ allowed := make(map[string]struct{}, len(selectable)+len(localNames))+ for _, model := range selectable {+ allowed[model.Name] = struct{}{}+ allowed[model.OllamaModel] = struct{}{}+ }+ for _, name := range localNames {+ allowed[strings.TrimSpace(name)] = struct{}{}+ }+ for _, name := range names {+ if _, ok := allowed[strings.TrimSpace(name)]; !ok {+ return nil, fmt.Errorf("model %q is not installed or recommended for Claude Desktop", name)+ }+ }++ selected := proxy.SelectClaudeDesktopModels(selectable, names)+ if len(selected) == 0 {+ return nil, errors.New("select at least one Claude Desktop model")+ }+ return selected, nil+}+func requestClaudeDesktopInstall() claudeDesktopInstallResult {return claudeDesktopInstallResultFromCode(int(C.installClaudeDesktop()))}+func claudeDesktopDownloadEndpoint(baseURL string) string {+ return strings.TrimRight(baseURL, "/") + "/download-app?app=claude-desktop&type=mac-zip"+}++//export ClaudeDesktopDownloadURL+func ClaudeDesktopDownloadURL() *C.char {+ return C.CString(claudeDownloadEndpoint())+}++//export InstallClaudeDesktopArchive+func InstallClaudeDesktopArchive(path *C.cchar_t) C.bool {+ archivePath := C.GoString((*C.char)(unsafe.Pointer(path)))+ installedPath, err := installClaudeDesktopZip(archivePath, claudeDesktopInstallDestinations(), verifyClaudeDesktopBundle)+ if errors.Is(err, errClaudeDesktopDestinationExists) && claudeDesktopInstalled() {+ slog.Info("Claude Desktop was installed while its download was in progress")+ return C._Bool(true)+ }+ if err != nil {+ slog.Warn("failed to install Claude Desktop archive", "error", err)+ return C._Bool(false)+ }+ slog.Info("installed Claude Desktop", "path", installedPath)+ return C._Bool(true)+}+func getShowAppsInMenu() bool {return bool(C.ShowAppsInMenu())}@@ -544,6 +1122,8 @@ func updateClaudeProxyMenu(counts proxy.ClaudeDesktopCounts) {}func stopClaudeAppProxy() {+ claudeProxyStartMu.Lock()+ defer claudeProxyStartMu.Unlock()claudeProxyMu.Lock()proxy := claudeAppProxyclaudeAppProxy = nildiff --git a/app/cmd/app/app_darwin.h b/app/cmd/app/app_darwin.hindex 025570d6e..da3098fdf 100644--- a/app/cmd/app/app_darwin.h+++ b/app/cmd/app/app_darwin.h@@ -45,12 +45,14 @@ void drag(uintptr_t wndPtr);void doubleClick(uintptr_t wndPtr);void handleConnectURL();bool SetClaudeGatewayInstalled(bool installed, bool restartClaude);+bool HasUsedClaudeDesktopIntegration(void);bool RestoreClaudeGatewayForShutdown(void);bool IsClaudeGatewayConfigured(void);bool IsClaudeDesktopInstalled(void);bool IsClaudeDesktopRunning(void);bool ClaudeGatewayStartFailed(void);bool ClaudeGatewayPortConflict(void);+char *ClaudeGatewayErrorMessage(void);int ClaudeGatewayPort(void);void RefreshClaudeProxyMenu(void);void updateClaudeProxyMenu(unsigned long long routed);@@ -63,3 +65,5 @@ enum ClaudeInstallResultClaudeInstallFailed,};enum ClaudeInstallResult installClaudeDesktop(void);+char *ClaudeDesktopDownloadURL(void);+bool InstallClaudeDesktopArchive(const char *archivePath);diff --git a/app/cmd/app/app_darwin.m b/app/cmd/app/app_darwin.mindex 703e43699..4e8546fc0 100644--- a/app/cmd/app/app_darwin.m+++ b/app/cmd/app/app_darwin.m@@ -8,11 +8,10 @@#import <ServiceManagement/ServiceManagement.h>#import <WebKit/WebKit.h>#import <objc/runtime.h>+#include <stdlib.h>extern NSString *SystemWidePath;-static NSString *const ClaudeDownloadURL =- @"https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect";static NSString *const ClaudeDownloadPageURL = @"https://claude.com/download";static NSString *const ShowAppsInMenuDefaultsKey = @"ShowAppsInMenu";static NSBundle *OllamaResourceBundle(void);@@ -343,6 +342,7 @@ static NSImage *integrationAppIcon(NSString *appName,- (enum ClaudeInstallResult)downloadClaude;- (enum ClaudeInstallResult)finishClaudeDownload;- (void)showClaudeDownloadFailure:(NSError *)error;+- (void)showClaudeInstallFailure:(NSError *)error;- (void)toggleClaudeAppProxy:(NSButton *)sender;- (void)refreshClaudeAppState;- (void)applyShowAppsInMenu:(BOOL)visible;@@ -630,6 +630,10 @@ static NSImage *ollamaApplicationIcon(void) {}- (void)refreshClaudeAppState {+ BOOL hasUsed = HasUsedClaudeDesktopIntegration();+ BOOL visible = shouldShowAppsInMenu() && hasUsed;+ [self.claudeMenuItem setHidden:!visible];+ [self.claudeMenuSeparatorItem setHidden:!visible];BOOL installed = IsClaudeDesktopInstalled();BOOL startFailed = ClaudeGatewayStartFailed();BOOL portConflict = startFailed && ClaudeGatewayPortConflict();@@ -649,6 +653,7 @@ static NSImage *ollamaApplicationIcon(void) {}- (void)applyShowAppsInMenu:(BOOL)visible {+ visible = visible && HasUsedClaudeDesktopIntegration();[self.claudeMenuItem setHidden:!visible];[self.claudeMenuSeparatorItem setHidden:!visible];}@@ -741,6 +746,23 @@ static NSImage *ollamaApplicationIcon(void) {}}+- (void)showClaudeInstallFailure:(NSError *)error {+ appLogInfo([NSString stringWithFormat:@"Unable to install Claude: %@",+ error]);+ NSAlert *alert = [[NSAlert alloc] init];+ [alert setAlertStyle:NSAlertStyleWarning];+ [alert setIcon:ollamaApplicationIcon()];+ [alert setMessageText:@"Claude couldn’t be installed"];+ [alert setInformativeText:+ @"Try again or install Claude from its website."];+ [alert addButtonWithTitle:@"Open download page"];+ [alert addButtonWithTitle:@"Cancel"];+ if ([alert runModal] == NSAlertFirstButtonReturn) {+ [[NSWorkspace sharedWorkspace]+ openURL:[NSURL URLWithString:ClaudeDownloadPageURL]];+ }+}+- (enum ClaudeInstallResult)downloadClaude {if (self.claudeDownloadTask != nil) {return ClaudeInstallCancelled;@@ -754,7 +776,7 @@ static NSImage *ollamaApplicationIcon(void) {[self.claudeDownloadAlert setIcon:ollamaApplicationIcon()];[self.claudeDownloadAlert setMessageText:@"Downloading Claude"];[self.claudeDownloadAlert setInformativeText:- @"The installer will open when the download finishes."];+ @"Claude will be installed when the download finishes."];[self.claudeDownloadAlert addButtonWithTitle:@"Cancel"];self.claudeDownloadProgress = [[NSProgressIndicator alloc]initWithFrame:NSMakeRect(0, 0, 260, 12)];@@ -775,8 +797,13 @@ static NSImage *ollamaApplicationIcon(void) {sessionWithConfiguration:configurationdelegate:selfdelegateQueue:[NSOperationQueue mainQueue]];+ char *downloadURL = ClaudeDesktopDownloadURL();+ NSString *downloadURLString = downloadURL == NULL+ ? nil+ : [NSString stringWithUTF8String:downloadURL];+ free(downloadURL);self.claudeDownloadTask = [self.claudeDownloadSession- downloadTaskWithURL:[NSURL URLWithString:ClaudeDownloadURL]];+ downloadTaskWithURL:[NSURL URLWithString:downloadURLString]];[NSApp activateIgnoringOtherApps:YES];[self.claudeDownloadTask resume];@@ -856,7 +883,7 @@ didFinishDownloadingToURL:(NSURL *)location {if (error == nil) {NSString *fileName = [NSString- stringWithFormat:@"Claude-%@.dmg", [NSUUID UUID].UUIDString];+ stringWithFormat:@"Claude-%@.zip", [NSUUID UUID].UUIDString];NSURL *installerURL = [NSURL fileURLWithPath:[NSTemporaryDirectory() stringByAppendingPathComponent:fileName]];if ([[NSFileManager defaultManager] moveItemAtURL:location@@ -922,21 +949,31 @@ didCompleteWithError:(NSError *)error {self.claudeDownloadCompleted = NO;return ClaudeInstallFailed;}- BOOL installerOpened = [[NSWorkspace sharedWorkspace]- openURL:self.claudeDownloadedInstallerURL];- if (!installerOpened) {- NSError *openError = [NSError+ [self.claudeAppRow setInactiveStatusText:@"Installing Claude…"];+ BOOL installed = InstallClaudeDesktopArchive(+ self.claudeDownloadedInstallerURL.fileSystemRepresentation);+ NSError *removeError = nil;+ [[NSFileManager defaultManager]+ removeItemAtURL:self.claudeDownloadedInstallerURL+ error:&removeError];+ if (removeError != nil) {+ appLogInfo([NSString stringWithFormat:+ @"Unable to remove downloaded Claude archive: %@", removeError]);+ }+ if (!installed) {+ NSError *installError = [NSErrorerrorWithDomain:@"com.ollama.app"code:4userInfo:@{NSLocalizedDescriptionKey:- @"The Claude installer could not be opened."}];- [self showClaudeDownloadFailure:openError];+ @"Claude could not be installed."}];+ [self showClaudeInstallFailure:installError];}self.claudeDownloadError = nil;self.claudeDownloadedInstallerURL = nil;self.claudeDownloadCancelled = NO;self.claudeDownloadCompleted = NO;- return installerOpened ? ClaudeInstallerOpened : ClaudeInstallFailed;+ [self refreshClaudeAppState];+ return installed ? ClaudeInstallerOpened : ClaudeInstallFailed;}- (void)toggleClaudeAppProxy:(NSButton *)sender {@@ -954,9 +991,12 @@ didCompleteWithError:(NSError *)error {[installAlert addButtonWithTitle:@"Download Claude"];[installAlert addButtonWithTitle:@"Cancel"];if ([installAlert runModal] == NSAlertFirstButtonReturn) {- [self downloadClaude];+ if ([self downloadClaude] != ClaudeInstallerOpened) {+ return;+ }+ } else {+ return;}- return;}BOOL restartClaude = IsClaudeDesktopRunning();if (restartClaude) {@@ -984,6 +1024,11 @@ didCompleteWithError:(NSError *)error {[sender setEnabled:YES];if (!succeeded) {BOOL portConflict = enabled && ClaudeGatewayPortConflict();+ char *rawGatewayError = ClaudeGatewayErrorMessage();+ NSString *gatewayError = rawGatewayError != NULL && rawGatewayError[0] != '\0'+ ? [NSString stringWithUTF8String:rawGatewayError]+ : nil;+ free(rawGatewayError);[self refreshClaudeAppState];NSAlert *alert = [[NSAlert alloc] init];[alert setAlertStyle:NSAlertStyleWarning];@@ -995,7 +1040,9 @@ didCompleteWithError:(NSError *)error {: @"Unable to remove Ollama from Claude")];[alert setInformativeText:portConflict? [NSString stringWithFormat:@"Change OLLAMA_HOST or quit the app using port %d, then try again.", ClaudeGatewayPort()]- : @"Ollama could not update Claude. Check the Ollama log for details."];+ : (gatewayError.length > 0+ ? gatewayError+ : @"Ollama could not update Claude. Check the Ollama log for details.")];[alert runModal];return;}diff --git a/app/cmd/app/app_darwin_test.go b/app/cmd/app/app_darwin_test.goindex 86d234a11..aac1a489b 100644--- a/app/cmd/app/app_darwin_test.go+++ b/app/cmd/app/app_darwin_test.go@@ -8,41 +8,585 @@ import ("net""net/http""net/http/httptest"+ "os"+ "path/filepath"+ "slices""strings""testing""time""github.com/ollama/ollama/api"+ "github.com/ollama/ollama/app/store"+ "github.com/ollama/ollama/cmd/launch""github.com/ollama/ollama/internal/proxy")-func TestClaudeCloudModelsAvailable(t *testing.T) {+func TestMain(m *testing.M) {+ previousLoader := claudeModelsLoader+ previousAccessResolver := claudeAccessStateResolver+ previousLocalResolver := claudeLocalModelsResolver+ claudeModelsLoader = func(context.Context) ([]proxy.ClaudeDesktopModel, string) {+ return proxy.DefaultClaudeDesktopModels(), "fallback"+ }+ claudeAccessStateResolver = func(context.Context) (proxy.ClaudeDesktopAccessState, error) {+ return proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudOn,+ Account: proxy.ClaudeDesktopAccountSignedIn,+ Plan: "pro",+ }, nil+ }+ claudeLocalModelsResolver = func(context.Context) ([]string, error) { return nil, nil }+ code := m.Run()+ claudeModelsLoader = previousLoader+ claudeAccessStateResolver = previousAccessResolver+ claudeLocalModelsResolver = previousLocalResolver+ os.Exit(code)+}++func TestLoadClaudeDesktopModelsUsesAppEndpoint(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path != "/api/experimental/model-recommendations" || r.URL.Query().Get("app") != "claude-desktop" {+ t.Fatalf("request URL = %q", r.URL.String())+ }+ _, _ = w.Write([]byte(`{"recommendations":[{"model":"glm-5.2:cloud","description":"Cloud model","max_output_tokens":262144,"required_plan":"pro"},{"model":"gemma4:26b","description":"Local model","max_output_tokens":262144}]}`))+ }))+ defer server.Close()++ previousClient := claudeRecommendationsClient+ previousEndpoint := claudeRecommendationsEndpoint+ claudeRecommendationsClient = server.Client()+ claudeRecommendationsEndpoint = func() string {+ return server.URL + "/api/experimental/model-recommendations?app=claude-desktop"+ }+ t.Cleanup(func() {+ claudeRecommendationsClient = previousClient+ claudeRecommendationsEndpoint = previousEndpoint+ })++ models, source := loadClaudeDesktopModels(context.Background())+ if source != "endpoint" || len(models) != 1 || models[0].Name != "glm-5.2:cloud" {+ t.Fatalf("models/source = %+v/%q", models, source)+ }+}++func TestClaudeDesktopDownloadEndpointUsesTypedZipContract(t *testing.T) {+ endpoint := claudeDesktopDownloadEndpoint("http://127.0.0.1:18080/")+ if endpoint != "http://127.0.0.1:18080/download-app?app=claude-desktop&type=mac-zip" {+ t.Fatalf("endpoint = %q", endpoint)+ }+}++func TestResolveClaudeDesktopCatalogUsesPersistedSelection(t *testing.T) {+ t.Setenv("HOME", t.TempDir())++ available, selected, source := resolveClaudeDesktopCatalog(context.Background())+ if source != "fallback" || len(selected) != len(available) {+ t.Fatalf("default catalog = %d/%d source %q, want all fallback models selected", len(selected), len(available), source)+ }++ if err := launch.SaveClaudeDesktopModels([]string{"qwen3:8b"}); err != nil {+ t.Fatal(err)+ }+ available, selected, source = resolveClaudeDesktopCatalog(context.Background())+ if source != "user" {+ t.Fatalf("source = %q, want user", source)+ }+ if len(selected) != 1 || selected[0].Name != "qwen3:8b" {+ t.Fatalf("selected models = %+v, want persisted qwen3:8b", selected)+ }+ if got := available[len(available)-1].Name; got != "qwen3:8b" {+ t.Fatalf("last available model = %q, want persisted qwen3:8b", got)+ }+}++func TestRefreshClaudeDesktopCatalogUpdatesPolicyAndPreservesSlots(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ previousLoader := claudeModelsLoader+ previousInterval := claudeCatalogRefreshInterval+ previousNow := claudeCatalogNow+ claudeProxyMu.Lock()+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAvailableModels = nil+ claudeModelSource = ""+ claudeCatalogUpdated = time.Time{}+ claudeProxyMu.Unlock()+ t.Cleanup(func() {+ claudeModelsLoader = previousLoader+ claudeCatalogRefreshInterval = previousInterval+ claudeCatalogNow = previousNow+ claudeProxyMu.Lock()+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ now := time.Unix(1_000, 0)+ claudeCatalogNow = func() time.Time { return now }+ claudeCatalogRefreshInterval = time.Minute+ load := 0+ claudeModelsLoader = func(context.Context) ([]proxy.ClaudeDesktopModel, string) {+ load+++ requiredPlan := "free"+ if load > 1 {+ requiredPlan = "pro"+ }+ return proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "changing-model:cloud", RequiredPlan: requiredPlan}}), "endpoint"+ }++ _, initial, _ := refreshClaudeDesktopCatalog(context.Background(), nil, false)+ if len(initial) != 1 {+ t.Fatalf("initial selection = %+v", initial)+ }+ initialID := initial[0].GatewayID()+ now = now.Add(2 * time.Minute)+ _, updated, _ := refreshClaudeDesktopCatalog(context.Background(), initial, false)+ if load != 2 {+ t.Fatalf("catalog loads = %d, want 2", load)+ }+ if len(updated) != 1 || updated[0].RequiredPlan != "pro" {+ t.Fatalf("updated selection = %+v, want Pro metadata", updated)+ }+ if updated[0].GatewayID() != initialID {+ t.Fatalf("gateway ID changed from %q to %q", initialID, updated[0].GatewayID())+ }+}++func TestRefreshClaudeDesktopCatalogFailsClosedForRemovedSelection(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ previousLoader := claudeModelsLoader+ previousInterval := claudeCatalogRefreshInterval+ previousNow := claudeCatalogNow+ claudeProxyMu.Lock()+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAvailableModels = nil+ claudeModelSource = ""+ claudeCatalogUpdated = time.Time{}+ claudeProxyMu.Unlock()+ t.Cleanup(func() {+ claudeModelsLoader = previousLoader+ claudeCatalogRefreshInterval = previousInterval+ claudeCatalogNow = previousNow+ claudeProxyMu.Lock()+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ now := time.Unix(2_000, 0)+ claudeCatalogNow = func() time.Time { return now }+ claudeCatalogRefreshInterval = time.Minute+ load := 0+ claudeModelsLoader = func(context.Context) ([]proxy.ClaudeDesktopModel, string) {+ load+++ name := "retired-model:cloud"+ if load > 1 {+ name = "replacement-model:cloud"+ }+ return proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: name, RequiredPlan: "free"}}), "endpoint"+ }++ _, initial, _ := refreshClaudeDesktopCatalog(context.Background(), nil, false)+ now = now.Add(2 * time.Minute)+ _, updated, _ := refreshClaudeDesktopCatalog(context.Background(), initial, false)+ if len(updated) != 1 || updated[0].Name != "retired-model:cloud" {+ t.Fatalf("updated selection = %+v, want preserved retired selection", updated)+ }+ state := proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "free"}+ access := proxy.EvaluateClaudeDesktopModelAccess(updated[0], state, false, true)+ if access.Reason != proxy.ClaudeDesktopAccessVerificationUnavailable {+ t.Fatalf("removed-model access = %+v, want verification unavailable", access)+ }+}++func TestRefreshClaudeDesktopCatalogDoesNotDowngradeEntitlementOnFallback(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ previousLoader := claudeModelsLoader+ previousInterval := claudeCatalogRefreshInterval+ previousNow := claudeCatalogNow+ claudeProxyMu.Lock()+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAvailableModels = nil+ claudeModelSource = ""+ claudeCatalogUpdated = time.Time{}+ claudeProxyMu.Unlock()+ t.Cleanup(func() {+ claudeModelsLoader = previousLoader+ claudeCatalogRefreshInterval = previousInterval+ claudeCatalogNow = previousNow+ claudeProxyMu.Lock()+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ now := time.Unix(3_000, 0)+ claudeCatalogNow = func() time.Time { return now }+ claudeCatalogRefreshInterval = time.Minute+ load := 0+ claudeModelsLoader = func(context.Context) ([]proxy.ClaudeDesktopModel, string) {+ load+++ if load == 1 {+ return proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "gemma4:31b-cloud", RequiredPlan: "pro"}}), "endpoint"+ }+ return proxy.DefaultClaudeDesktopModels(), "fallback"+ }++ _, initial, _ := refreshClaudeDesktopCatalog(context.Background(), nil, false)+ now = now.Add(2 * time.Minute)+ _, updated, _ := refreshClaudeDesktopCatalog(context.Background(), initial, false)+ if len(updated) != 1 || updated[0].RequiredPlan != "pro" {+ t.Fatalf("fallback selection = %+v, want last-known Pro requirement", updated)+ }+ state := proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "free"}+ access := proxy.EvaluateClaudeDesktopModelAccess(updated[0], state, false, true)+ if access.Reason != proxy.ClaudeDesktopAccessUpgradeRequired {+ t.Fatalf("fallback access = %+v, want upgrade required", access)+ }+}++func TestIncludeSelectedClaudeDesktopModelsKeepsCustomModels(t *testing.T) {+ available := proxy.DefaultClaudeDesktopModels()+ selected := proxy.SelectClaudeDesktopModels(available, []string{"qwen3:8b"})+ models := includeSelectedClaudeDesktopModels(available, selected)+ if got := models[len(models)-1].Name; got != "qwen3:8b" {+ t.Fatalf("last available model = %q, want qwen3:8b", got)+ }+}++func TestSelectKnownClaudeDesktopModelsAllowsInstalledModelsOnly(t *testing.T) {+ available := proxy.DefaultClaudeDesktopModels()+ selected, err := selectKnownClaudeDesktopModels(available, nil, []string{"qwen3:8b"}, []string{"qwen3:8b"})+ if err != nil {+ t.Fatal(err)+ }+ if len(selected) != 1 || selected[0].Name != "qwen3:8b" {+ t.Fatalf("selected models = %+v, want installed qwen3:8b", selected)+ }++ selected, err = selectKnownClaudeDesktopModels(available, nil, nil, []string{"deepseek-v4-flash:0731:cloud"})+ if err != nil {+ t.Fatal(err)+ }+ if len(selected) != 1 || selected[0].Name != "deepseek-v4-flash" || selected[0].OllamaModel != "deepseek-v4-flash:0731:cloud" {+ t.Fatalf("selected cloud model = %+v", selected)+ }++ if _, err := selectKnownClaudeDesktopModels(available, nil, []string{"qwen3:8b"}, []string{"made-up-model"}); err == nil {+ t.Fatal("expected an arbitrary model name to be rejected")+ }++ // The five-model selection cap must not make later installed models+ // unselectable. The cap applies to the final selection, not the inventory.+ localNames := []string{"local-1", "local-2", "local-3", "local-4", "local-5", "local-6"}+ selected, err = selectKnownClaudeDesktopModels(available, nil, localNames, []string{"local-6"})+ if err != nil {+ t.Fatal(err)+ }+ if len(selected) != 1 || selected[0].Name != "local-6" {+ t.Fatalf("later installed model selection = %+v, want local-6", selected)+ }+}++type fakeClaudeDesktopController struct {+ configured bool+ installed bool+ restart bool+ setErr error+ modelsAtSet []string+ configureOnSet bool+}++func (f *fakeClaudeDesktopController) UsesOllamaGateway() bool { return f.configured }++func (f *fakeClaudeDesktopController) ConfigureAutodiscovery() error {+ f.configured = true+ return nil+}++func (f *fakeClaudeDesktopController) SetInstalledFromDesktop(installed, restart bool) error {+ f.installed = installed+ f.restart = restart+ f.modelsAtSet = launch.ClaudeDesktopModels()+ if f.configureOnSet {+ f.configured = installed+ }+ return f.setErr+}++func (f *fakeClaudeDesktopController) RestartWithProfileChange(change func() error) error {+ if err := change(); err != nil {+ return err+ }+ f.installed = true+ f.restart = true+ f.modelsAtSet = launch.ClaudeDesktopModels()+ return f.setErr+}++func (f *fakeClaudeDesktopController) RestoreForShutdown(context.Context) error { return nil }++func TestRestartClaudeDesktopWithModelsPersistsSelection(t *testing.T) {+ t.Setenv("HOME", t.TempDir())++ previousInstalled := claudeDesktopInstalled+ previousAddr := claudeProxyListenAddr+ previousDesktop := claudeDesktop+ claudeDesktopInstalled = func() bool { return true }+ claudeProxyListenAddr = "127.0.0.1:0"+ fake := &fakeClaudeDesktopController{configured: true}+ claudeDesktop = fake+ t.Cleanup(func() {+ stopClaudeAppProxy()+ claudeDesktopInstalled = previousInstalled+ claudeProxyListenAddr = previousAddr+ claudeDesktop = previousDesktop+ })++ if err := restartClaudeDesktopWithModels([]string{"kimi-k3:cloud"}); err != nil {+ t.Fatal(err)+ }+ if !fake.installed {+ t.Fatal("expected the Claude profile to be installed")+ }+ if got, want := launch.ClaudeDesktopModels(), []string{"kimi-k3:cloud"}; !slices.Equal(got, want) {+ t.Fatalf("persisted models = %v, want Ollama routes %v", got, want)+ }+}++func TestRestartClaudeDesktopWithModelsRollsBackWhenRestartFails(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ if err := launch.SaveClaudeDesktopModels([]string{"glm-5.2:cloud"}); err != nil {+ t.Fatal(err)+ }+ models := proxy.SelectClaudeDesktopModels(proxy.DefaultClaudeDesktopModels(), []string{"glm-5.2:cloud"})+ gateway, err := proxy.NewClaudeDesktop(proxy.ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: "http://127.0.0.1:11434",+ Model: models[0].OllamaModel,+ Models: models,+ })+ if err != nil {+ t.Fatal(err)+ }++ previousInstalled := claudeDesktopInstalled+ previousDesktop := claudeDesktop+ claudeProxyMu.Lock()+ previousGateway := claudeAppProxy+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAppProxy = gateway+ claudeAvailableModels = proxy.DefaultClaudeDesktopModels()+ claudeModelSource = "endpoint"+ claudeCatalogUpdated = claudeCatalogNow()+ claudeProxyMu.Unlock()+ claudeDesktopInstalled = func() bool { return true }+ fake := &fakeClaudeDesktopController{configured: true, setErr: errors.New("restart failed")}+ claudeDesktop = fake+ t.Cleanup(func() {+ claudeDesktopInstalled = previousInstalled+ claudeDesktop = previousDesktop+ claudeProxyMu.Lock()+ claudeAppProxy = previousGateway+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ err = restartClaudeDesktopWithModels([]string{"kimi-k3:cloud"})+ if err == nil || !strings.Contains(err.Error(), "restart failed") {+ t.Fatalf("restart error = %v", err)+ }+ if got := launch.ClaudeDesktopModels(); !slices.Equal(got, []string{"glm-5.2:cloud"}) {+ t.Fatalf("persisted models after failure = %v", got)+ }+ if !slices.Equal(fake.modelsAtSet, []string{"kimi-k3:cloud"}) {+ t.Fatalf("models visible before restart = %v, want new selection", fake.modelsAtSet)+ }+ gotModels := gateway.Models()+ if len(gotModels) != 1 || gotModels[0].OllamaModel != "glm-5.2:cloud" {+ t.Fatalf("live gateway models after failure = %+v", gotModels)+ }+}++func TestFirstConnectKeepsModelsWhenProfileCommitsButOpenFails(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ if err := launch.SaveClaudeDesktopModels([]string{"glm-5.2:cloud"}); err != nil {+ t.Fatal(err)+ }+ previousInstalled := claudeDesktopInstalled+ previousDesktop := claudeDesktop+ previousAddr := claudeProxyListenAddr+ claudeProxyMu.Lock()+ previousGateway := claudeAppProxy+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAppProxy = nil+ claudeAvailableModels = nil+ claudeModelSource = ""+ claudeCatalogUpdated = time.Time{}+ claudeProxyMu.Unlock()+ claudeDesktopInstalled = func() bool { return true }+ claudeProxyListenAddr = "127.0.0.1:0"+ fake := &fakeClaudeDesktopController{setErr: errors.New("open failed"), configureOnSet: true}+ claudeDesktop = fake+ t.Cleanup(func() {+ stopClaudeAppProxy()+ claudeDesktopInstalled = previousInstalled+ claudeDesktop = previousDesktop+ claudeProxyListenAddr = previousAddr+ claudeProxyMu.Lock()+ claudeAppProxy = previousGateway+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ err := restartClaudeDesktopWithModels([]string{"kimi-k3:cloud"})+ if err == nil || !strings.Contains(err.Error(), "open failed") {+ t.Fatalf("connect error = %v", err)+ }+ if !fake.configured {+ t.Fatal("profile did not remain configured after the open failure")+ }+ if got := launch.ClaudeDesktopModels(); !slices.Equal(got, []string{"kimi-k3:cloud"}) {+ t.Fatalf("persisted models after open failure = %v", got)+ }+ claudeProxyMu.Lock()+ gateway := claudeAppProxy+ claudeProxyMu.Unlock()+ if gateway == nil {+ t.Fatal("gateway stopped after the profile committed")+ }+ models := gateway.Models()+ if len(models) != 1 || models[0].OllamaModel != "kimi-k3:cloud" {+ t.Fatalf("live models after open failure = %+v", models)+ }+}++func TestRestartClaudeDesktopWithModelsCapsSelectionAtLiteralSlots(t *testing.T) {+ t.Setenv("HOME", t.TempDir())++ previousInstalled := claudeDesktopInstalled+ previousDesktop := claudeDesktop+ claudeDesktopInstalled = func() bool { return true }+ fake := &fakeClaudeDesktopController{configured: true}+ claudeDesktop = fake+ t.Cleanup(func() {+ claudeDesktopInstalled = previousInstalled+ claudeDesktop = previousDesktop+ })++ err := restartClaudeDesktopWithModels([]string{+ "glm-5.2:cloud",+ "kimi-k3:cloud",+ "deepseek-v4-pro",+ "deepseek-v4-flash",+ "gemma4:26b:cloud",+ "qwen3:8b",+ })+ if err == nil || !strings.Contains(err.Error(), "at most 5") {+ t.Fatalf("error = %v, want a clear at most 5 message", err)+ }+ if fake.installed {+ t.Fatal("the Claude profile must not change when the selection exceeds the model limit")+ }+}++func TestClaudeDesktopIntegrationHistoryPersists(t *testing.T) {+ previousStore := appStore+ appStore = &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}+ t.Cleanup(func() {+ _ = appStore.Close()+ appStore = previousStore+ })++ if hasUsedClaudeDesktopIntegration() {+ t.Fatal("expected no Claude Desktop integration history initially")+ }+ if err := markClaudeDesktopIntegrationUsed(); err != nil {+ t.Fatal(err)+ }+ if !hasUsedClaudeDesktopIntegration() {+ t.Fatal("expected Claude Desktop integration history after marking it used")+ }+}++func TestLoadClaudeDesktopModelsFallsBackWithoutMLX(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ http.Error(w, "unavailable", http.StatusServiceUnavailable)+ }))+ defer server.Close()++ previousClient := claudeRecommendationsClient+ previousEndpoint := claudeRecommendationsEndpoint+ claudeRecommendationsClient = server.Client()+ claudeRecommendationsEndpoint = func() string { return server.URL }+ t.Cleanup(func() {+ claudeRecommendationsClient = previousClient+ claudeRecommendationsEndpoint = previousEndpoint+ })++ models, source := loadClaudeDesktopModels(context.Background())+ if source != "fallback" || len(models) != 5 {+ t.Fatalf("models/source = %+v/%q", models, source)+ }+ for _, model := range models {+ if strings.Contains(strings.ToLower(model.Name), "mlx") {+ t.Fatalf("fallback contains MLX model %q", model.Name)+ }+ access := proxy.EvaluateClaudeDesktopModelAccess(+ model,+ proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "pro"},+ false,+ true,+ )+ if access.Reason != proxy.ClaudeDesktopAccessVerificationUnavailable {+ t.Fatalf("cold fallback access for %q = %+v, want verification unavailable", model.Name, access)+ }+ }+}++func TestResolveClaudeDesktopAccessState(t *testing.T) {tests := []struct {name stringcloudStatus func(context.Context) (*api.StatusResponse, error)whoami func(context.Context) (*api.UserResponse, error)- want bool+ want proxy.ClaudeDesktopAccessState}{{name: "signed in",whoami: func(context.Context) (*api.UserResponse, error) {- return &api.UserResponse{Name: "parth"}, nil+ return &api.UserResponse{Name: "parth", Plan: "pro"}, nil},- want: true,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "pro"},},{name: "signed out",whoami: func(context.Context) (*api.UserResponse, error) {return nil, api.AuthorizationError{StatusCode: http.StatusUnauthorized}},- want: false,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedOut},},{name: "empty account",whoami: func(context.Context) (*api.UserResponse, error) {return &api.UserResponse{}, nil},- want: false,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedOut},},{name: "cloud disabled",@@ -53,7 +597,7 @@ func TestClaudeCloudModelsAvailable(t *testing.T) {t.Fatal("whoami called while cloud was disabled")return nil, nil},- want: false,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOff, Account: proxy.ClaudeDesktopAccountUnknown},},{name: "cloud status unavailable",@@ -63,14 +607,14 @@ func TestClaudeCloudModelsAvailable(t *testing.T) {whoami: func(context.Context) (*api.UserResponse, error) {return &api.UserResponse{Name: "parth"}, nil},- want: true,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudUnknown, Account: proxy.ClaudeDesktopAccountUnknown},},{name: "account check unavailable",whoami: func(context.Context) (*api.UserResponse, error) {return nil, errors.New("account service unavailable")},- want: true,+ want: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountUnknown},},}@@ -82,8 +626,216 @@ func TestClaudeCloudModelsAvailable(t *testing.T) {return &api.StatusResponse{}, nil}}- if got := claudeCloudModelsAvailable(context.Background(), cloudStatus, tt.whoami); got != tt.want {- t.Fatalf("claudeCloudModelsAvailable() = %v, want %v", got, tt.want)+ got, _ := resolveClaudeDesktopAccessState(context.Background(), cloudStatus, tt.whoami)+ if got != tt.want {+ t.Fatalf("resolveClaudeDesktopAccessState() = %+v, want %+v", got, tt.want)+ }+ })+ }+}++func TestValidateClaudeDesktopModels(t *testing.T) {+ local := proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "qwen3:8b"}})+ free := proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "gemma4:31b-cloud", RequiredPlan: "free"}})+ pro := proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "glm-5.2:cloud", RequiredPlan: "pro"}})++ tests := []struct {+ name string+ models []proxy.ClaudeDesktopModel+ state proxy.ClaudeDesktopAccessState+ localNames []string+ inventoryKnown bool+ wantError string+ }{+ {+ name: "installed local works with cloud off",+ models: local,+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOff},+ localNames: []string{"qwen3:8b"},+ inventoryKnown: true,+ },+ {+ name: "free cloud model works for free account",+ models: free,+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "free"},+ inventoryKnown: true,+ },+ {+ name: "cloud disabled by configuration or environment",+ models: free,+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOff},+ inventoryKnown: true,+ wantError: "Cloud models are off",+ },+ {+ name: "signed out",+ models: free,+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedOut},+ inventoryKnown: true,+ wantError: "Sign in to Ollama",+ },+ {+ name: "plan upgrade required",+ models: pro,+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOn, Account: proxy.ClaudeDesktopAccountSignedIn, Plan: "free"},+ inventoryKnown: true,+ wantError: "Select another model in Settings",+ },+ {+ name: "local model missing",+ models: local,+ inventoryKnown: true,+ wantError: "Install the selected model",+ },+ {+ name: "access unavailable",+ models: free,+ wantError: "couldn't verify",+ },+ {+ name: "empty selection",+ inventoryKnown: true,+ wantError: "Choose at least one model",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ err := validateClaudeDesktopModels(tt.models, tt.state, tt.localNames, tt.inventoryKnown)+ if tt.wantError == "" {+ if err != nil {+ t.Fatalf("validateClaudeDesktopModels() error = %v", err)+ }+ return+ }+ if err == nil || !strings.Contains(err.Error(), tt.wantError) {+ t.Fatalf("validateClaudeDesktopModels() error = %v, want %q", err, tt.wantError)+ }+ })+ }+}++func TestEnsureClaudeDesktopModelsAvailableRetriesStartupRace(t *testing.T) {+ previousAccessResolver := claudeAccessStateResolver+ previousLocalResolver := claudeLocalModelsResolver+ previousRetryWait := claudeAccessRetryWait+ previousRetryPoll := claudeAccessRetryPoll+ claudeAccessRetryWait = time.Second+ claudeAccessRetryPoll = time.Millisecond+ calls := 0+ claudeAccessStateResolver = func(context.Context) (proxy.ClaudeDesktopAccessState, error) {+ calls+++ if calls == 1 {+ return proxy.ClaudeDesktopAccessState{}, errors.New("server starting")+ }+ return proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudOn,+ Account: proxy.ClaudeDesktopAccountSignedIn,+ Plan: "free",+ }, nil+ }+ claudeLocalModelsResolver = func(context.Context) ([]string, error) { return nil, nil }+ t.Cleanup(func() {+ claudeAccessStateResolver = previousAccessResolver+ claudeLocalModelsResolver = previousLocalResolver+ claudeAccessRetryWait = previousRetryWait+ claudeAccessRetryPoll = previousRetryPoll+ })++ models := proxy.ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{+ Model: "gemma4:31b-cloud",+ RequiredPlan: "free",+ }})+ if err := ensureClaudeDesktopModelsAvailable(context.Background(), models); err != nil {+ t.Fatal(err)+ }+ if calls != 2 {+ t.Fatalf("access checks = %d, want 2", calls)+ }+}++func TestSetClaudeGatewayInstalledRejectsEmptyUsableCatalog(t *testing.T) {+ tests := []struct {+ name string+ state proxy.ClaudeDesktopAccessState+ selection []string+ wantError string+ }{+ {+ name: "signed out",+ state: proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudOn,+ Account: proxy.ClaudeDesktopAccountSignedOut,+ },+ wantError: "Sign in to Ollama",+ },+ {+ name: "OLLAMA_NO_CLOUD or Cloud setting disabled",+ state: proxy.ClaudeDesktopAccessState{Cloud: proxy.ClaudeDesktopCloudOff},+ wantError: "Cloud models are off",+ },+ {+ name: "free account with only Pro selected",+ state: proxy.ClaudeDesktopAccessState{+ Cloud: proxy.ClaudeDesktopCloudOn,+ Account: proxy.ClaudeDesktopAccountSignedIn,+ Plan: "free",+ },+ selection: []string{"glm-5.2:cloud"},+ wantError: "Select another model in Settings",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ previousStore := appStore+ appStore = &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}+ if len(tt.selection) > 0 {+ if err := launch.SaveClaudeDesktopModels(tt.selection); err != nil {+ t.Fatal(err)+ }+ }++ previousInstalled := claudeDesktopInstalled+ previousAddr := claudeProxyListenAddr+ previousDesktop := claudeDesktop+ previousAccessResolver := claudeAccessStateResolver+ previousLocalResolver := claudeLocalModelsResolver+ claudeDesktopInstalled = func() bool { return true }+ claudeProxyListenAddr = "127.0.0.1:0"+ fake := &fakeClaudeDesktopController{}+ claudeDesktop = fake+ claudeAccessStateResolver = func(context.Context) (proxy.ClaudeDesktopAccessState, error) {+ return tt.state, nil+ }+ claudeLocalModelsResolver = func(context.Context) ([]string, error) { return nil, nil }+ t.Cleanup(func() {+ stopClaudeAppProxy()+ _ = appStore.Close()+ appStore = previousStore+ claudeDesktopInstalled = previousInstalled+ claudeProxyListenAddr = previousAddr+ claudeDesktop = previousDesktop+ claudeAccessStateResolver = previousAccessResolver+ claudeLocalModelsResolver = previousLocalResolver+ claudeProxyMu.Lock()+ clearClaudeProxyFailure()+ claudeProxyMu.Unlock()+ })++ err := setClaudeGatewayInstalled(true, false)+ if err == nil || !strings.Contains(err.Error(), tt.wantError) {+ t.Fatalf("setClaudeGatewayInstalled() error = %v, want %q", err, tt.wantError)+ }+ if fake.installed {+ t.Fatal("Claude profile changed without a usable model")+ }+ if claudeAppProxy != nil {+ t.Fatal("Claude gateway started without a usable model")+ }+ if !hasUsedClaudeDesktopIntegration() {+ t.Fatal("failed enable did not expose Claude recovery settings")}})}@@ -96,12 +848,14 @@ func TestClaudeLocalModels(t *testing.T) {{Name: "alias:latest", Model: "original:latest"},{Name: "remote-model:latest", Model: "remote-model:latest", RemoteModel: "upstream/model"},{Name: "remote-host:latest", Model: "remote-host:latest", RemoteHost: "https://ollama.com"},+ {Name: "cloud-source:cloud", Model: "cloud-source:cloud"},+ {Name: "legacy-cloud:31b-cloud", Model: "legacy-cloud:31b-cloud"},}}, nil})if err != nil {t.Fatal(err)}- if got := strings.Join(models, ","); got != "qwen3.8:27b-mlx,alias:latest,original:latest" {+ if got := strings.Join(models, ","); got != "qwen3.8:27b-mlx,alias:latest,alias,original:latest,original" {t.Fatalf("local models = %q", got)}models, err = claudeLocalModels(context.Background(), func(context.Context) (*api.ListResponse, error) {@@ -124,6 +878,82 @@ func TestClaudeLocalModels(t *testing.T) {}}+func TestClaudeGatewayStartupWithLocalSelectionSkipsCloudLookups(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ t.Setenv("OLLAMA_HOST", "127.0.0.1:11434")+ if err := launch.SaveClaudeDesktopModels([]string{"qwen3:8b"}); err != nil {+ t.Fatal(err)+ }+ previousInstalled := claudeDesktopInstalled+ previousStore := appStore+ appStore = &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}+ if err := markClaudeDesktopIntegrationUsed(); err != nil {+ t.Fatal(err)+ }+ previousAddr := claudeProxyListenAddr+ previousLoader := claudeModelsLoader+ previousAccess := claudeAccessStateResolver+ previousLocal := claudeLocalModelsResolver+ claudeProxyMu.Lock()+ previousGateway := claudeAppProxy+ previousAvailable := claudeAvailableModels+ previousSource := claudeModelSource+ previousUpdated := claudeCatalogUpdated+ claudeAppProxy = nil+ claudeProxyMu.Unlock()+ claudeDesktopInstalled = func() bool { return true }+ claudeProxyListenAddr = "127.0.0.1:0"+ loaderCalls := 0+ accessCalls := 0+ claudeModelsLoader = func(context.Context) ([]proxy.ClaudeDesktopModel, string) {+ loaderCalls+++ return nil, "fallback"+ }+ claudeAccessStateResolver = func(context.Context) (proxy.ClaudeDesktopAccessState, error) {+ accessCalls+++ return proxy.ClaudeDesktopAccessState{}, errors.New("offline")+ }+ claudeLocalModelsResolver = func(context.Context) ([]string, error) {+ return []string{"qwen3:8b"}, nil+ }+ t.Cleanup(func() {+ stopClaudeAppProxy()+ _ = appStore.Close()+ appStore = previousStore+ claudeDesktopInstalled = previousInstalled+ claudeProxyListenAddr = previousAddr+ claudeModelsLoader = previousLoader+ claudeAccessStateResolver = previousAccess+ claudeLocalModelsResolver = previousLocal+ claudeProxyMu.Lock()+ claudeAppProxy = previousGateway+ claudeAvailableModels = previousAvailable+ claudeModelSource = previousSource+ claudeCatalogUpdated = previousUpdated+ claudeProxyMu.Unlock()+ })++ if err := startClaudeAppProxy(); err != nil {+ t.Fatal(err)+ }+ if loaderCalls != 0 || accessCalls != 0 {+ t.Fatalf("cloud startup calls = recommendations:%d access:%d, want zero", loaderCalls, accessCalls)+ }+ status := getClaudeDesktopConnectionStatus()+ if len(status.Models) != 1 || status.Models[0].Name != "qwen3:8b" {+ t.Fatalf("local status models = %+v", status.Models)+ }+ if loaderCalls != 0 || accessCalls != 0 {+ t.Fatalf("cloud status calls = recommendations:%d access:%d, want zero", loaderCalls, accessCalls)+ }+ claudeProxyMu.Lock()+ models := claudeAppProxy.Models()+ claudeProxyMu.Unlock()+ if len(models) != 1 || models[0].OllamaModel != "qwen3:8b" {+ t.Fatalf("startup models = %+v", models)+ }+}+func TestRestoreClaudeBeforeQuit(t *testing.T) {called := falseif err := restoreClaudeBeforeQuit(context.Background(), false, false, func(context.Context) error {@@ -200,10 +1030,29 @@ func TestClaudeDesktopConnectionStatusReportsMissingApp(t *testing.T) {}}-func TestClaudeDesktopConnectionStatusSeparatesConfigurationFromGatewayHealth(t *testing.T) {- status := claudeDesktopConnectionStatus(true, true, false, errors.New("gateway failed"))+func TestClaudeDesktopConnectionStatusKeepsConfiguredStateOnGatewayFailure(t *testing.T) {+ previousInstalled := claudeDesktopInstalled+ previousDesktop := claudeDesktop+ claudeProxyMu.Lock()+ previousErr := claudeProxyErr+ previousFailure := claudeProxyFail+ claudeProxyErr = errors.New("gateway failed")+ claudeProxyFail = claudeProxyFailurePortConflict+ claudeProxyMu.Unlock()+ claudeDesktopInstalled = func() bool { return true }+ claudeDesktop = &fakeClaudeDesktopController{configured: true}+ t.Cleanup(func() {+ claudeDesktopInstalled = previousInstalled+ claudeDesktop = previousDesktop+ claudeProxyMu.Lock()+ claudeProxyErr = previousErr+ claudeProxyFail = previousFailure+ claudeProxyMu.Unlock()+ })++ status := getClaudeDesktopConnectionStatus()if !status.Configured || status.Connected || !status.StartFailed {- t.Fatalf("Claude status = %+v, want configured with failed gateway", status)+ t.Fatalf("Claude status = %+v, want configured but unavailable", status)}}@@ -292,6 +1141,7 @@ func TestClaudeGatewayDoesNotReportPortConflictWithoutClaude(t *testing.T) {}func TestClaudeGatewayRecoversAfterPortConflict(t *testing.T) {+ t.Setenv("HOME", t.TempDir())setClaudeProxyRetry(t, 20*time.Millisecond, 5*time.Millisecond)conflict := httptest.NewServer(http.NotFoundHandler())t.Cleanup(conflict.Close)@@ -336,6 +1186,7 @@ func TestClaudeGatewayRecoversAfterPortConflict(t *testing.T) {}func TestClaudeGatewayRejectsSpoofedExistingGateway(t *testing.T) {+ t.Setenv("HOME", t.TempDir())setClaudeProxyRetry(t, 20*time.Millisecond, 5*time.Millisecond)spoof := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {w.Header().Set("X-Ollama-Claude-Gateway", "1")@@ -362,6 +1213,7 @@ func TestClaudeGatewayRejectsSpoofedExistingGateway(t *testing.T) {}func TestClaudeGatewayWaitsForPreviousListenerToExit(t *testing.T) {+ t.Setenv("HOME", t.TempDir())setClaudeProxyRetry(t, 500*time.Millisecond, 5*time.Millisecond)listener, err := net.Listen("tcp", "127.0.0.1:0")if err != nil {diff --git a/app/cmd/app/claude_desktop_bindings_darwin.go b/app/cmd/app/claude_desktop_bindings_darwin.goindex 3015f41ff..b923bfa6a 100644--- a/app/cmd/app/claude_desktop_bindings_darwin.go+++ b/app/cmd/app/claude_desktop_bindings_darwin.go@@ -42,6 +42,15 @@ func bindClaudeDesktop(wv webview.WebView) {return requestClaudeDesktopInstall()})+ wv.Bind("restartClaudeDesktop", func(models []string) claudeDesktopActionResult {+ err := restartClaudeDesktopWithModels(models)+ result := claudeDesktopActionResult{Status: getClaudeDesktopConnectionStatus()}+ if err != nil {+ result.Error = err.Error()+ }+ return result+ })+wv.Bind("getShowAppsInMenu", func() bool {return getShowAppsInMenu()})diff --git a/app/cmd/app/claude_desktop_installer_darwin.go b/app/cmd/app/claude_desktop_installer_darwin.gonew file mode 100644index 000000000..5e9c4d3a3--- /dev/null+++ b/app/cmd/app/claude_desktop_installer_darwin.go@@ -0,0 +1,252 @@+//go:build darwin++package main++import (+ "archive/zip"+ "errors"+ "fmt"+ "io"+ "os"+ "os/exec"+ "path/filepath"+ "strings"+)++const (+ maxClaudeDesktopArchiveBytes = 1 << 30+ maxClaudeDesktopExtractBytes = 2 << 30+ maxClaudeDesktopArchiveFiles = 100_000+ claudeDesktopBundleID = "com.anthropic.claudefordesktop"+ claudeDesktopTeamID = "Q6L2SF6YDW"+)++var errClaudeDesktopDestinationExists = errors.New("Claude Desktop installation destination already exists")++func claudeDesktopInstallDestinations() []string {+ destinations := []string{"/Applications/Claude.app"}+ if home, err := os.UserHomeDir(); err == nil {+ destinations = append(destinations, filepath.Join(home, "Applications", "Claude.app"))+ }+ return destinations+}++func installClaudeDesktopZip(archivePath string, destinations []string, verify func(string) error) (string, error) {+ if len(destinations) == 0 {+ return "", errors.New("Claude Desktop installation destination is required")+ }+ if verify == nil {+ return "", errors.New("Claude Desktop bundle verifier is required")+ }+ info, err := os.Stat(archivePath)+ if err != nil {+ return "", fmt.Errorf("stat Claude Desktop archive: %w", err)+ }+ if !info.Mode().IsRegular() {+ return "", errors.New("Claude Desktop archive is not a regular file")+ }+ if info.Size() > maxClaudeDesktopArchiveBytes {+ return "", fmt.Errorf("Claude Desktop archive exceeds %d bytes", maxClaudeDesktopArchiveBytes)+ }++ workDir, err := os.MkdirTemp("", "ollama-claude-install-")+ if err != nil {+ return "", fmt.Errorf("create Claude Desktop installation directory: %w", err)+ }+ defer os.RemoveAll(workDir)++ if err := extractClaudeDesktopZip(archivePath, workDir); err != nil {+ return "", err+ }+ bundlePath := filepath.Join(workDir, "Claude.app")+ if err := validateClaudeDesktopBundle(bundlePath); err != nil {+ return "", err+ }+ if err := verify(bundlePath); err != nil {+ return "", fmt.Errorf("verify Claude Desktop signature: %w", err)+ }++ var permissionErr error+ for _, destination := range destinations {+ if strings.TrimSpace(destination) == "" {+ continue+ }+ if _, err := os.Stat(destination); err == nil {+ return "", fmt.Errorf("%w: %s", errClaudeDesktopDestinationExists, destination)+ } else if !errors.Is(err, os.ErrNotExist) {+ return "", fmt.Errorf("check Claude Desktop destination %s: %w", destination, err)+ }+ if err := os.MkdirAll(filepath.Dir(destination), 0o755); err != nil {+ if errors.Is(err, os.ErrPermission) {+ permissionErr = err+ continue+ }+ return "", fmt.Errorf("create Claude Desktop destination: %w", err)+ }+ if err := os.Rename(bundlePath, destination); err != nil {+ if errors.Is(err, os.ErrPermission) {+ permissionErr = err+ continue+ }+ return "", fmt.Errorf("move Claude Desktop to %s: %w", destination, err)+ }+ return destination, nil+ }+ if permissionErr != nil {+ return "", fmt.Errorf("install Claude Desktop in Applications: %w", permissionErr)+ }+ return "", errors.New("Claude Desktop installation destination is required")+}++func extractClaudeDesktopZip(archivePath, destination string) error {+ reader, err := zip.OpenReader(archivePath)+ if err != nil {+ return fmt.Errorf("open Claude Desktop archive: %w", err)+ }+ defer reader.Close()+ if len(reader.File) == 0 {+ return errors.New("Claude Desktop archive is empty")+ }+ if len(reader.File) > maxClaudeDesktopArchiveFiles {+ return fmt.Errorf("Claude Desktop archive contains more than %d files", maxClaudeDesktopArchiveFiles)+ }++ var expanded uint64+ for _, file := range reader.File {+ clean, err := safeClaudeDesktopArchivePath(file.Name)+ if err != nil {+ return err+ }+ expanded += file.UncompressedSize64+ if expanded > maxClaudeDesktopExtractBytes {+ return fmt.Errorf("Claude Desktop archive expands beyond %d bytes", maxClaudeDesktopExtractBytes)+ }+ path := filepath.Join(destination, filepath.FromSlash(clean))+ switch {+ case file.FileInfo().IsDir():+ if err := os.MkdirAll(path, file.Mode().Perm()); err != nil {+ return fmt.Errorf("create Claude Desktop archive directory: %w", err)+ }+ case file.Mode()&os.ModeSymlink != 0:+ target, err := readClaudeDesktopZipFile(file, 16<<10)+ if err != nil {+ return fmt.Errorf("read Claude Desktop archive symlink: %w", err)+ }+ if err := validateClaudeDesktopSymlink(clean, string(target)); err != nil {+ return err+ }+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return fmt.Errorf("create Claude Desktop archive directory: %w", err)+ }+ if err := os.Symlink(string(target), path); err != nil {+ return fmt.Errorf("create Claude Desktop archive symlink: %w", err)+ }+ case file.Mode().IsRegular():+ if err := extractClaudeDesktopZipFile(file, path); err != nil {+ return err+ }+ default:+ return fmt.Errorf("Claude Desktop archive contains unsupported file %q", file.Name)+ }+ }+ return nil+}++func safeClaudeDesktopArchivePath(name string) (string, error) {+ if strings.ContainsRune(name, '\x00') || filepath.IsAbs(name) {+ return "", fmt.Errorf("Claude Desktop archive contains unsafe path %q", name)+ }+ clean := filepath.ToSlash(filepath.Clean(name))+ if clean != "Claude.app" && !strings.HasPrefix(clean, "Claude.app/") {+ return "", fmt.Errorf("Claude Desktop archive contains unexpected path %q", name)+ }+ return clean, nil+}++func validateClaudeDesktopSymlink(name, target string) error {+ if target == "" || filepath.IsAbs(target) {+ return fmt.Errorf("Claude Desktop archive contains unsafe symlink %q", name)+ }+ resolved := filepath.Clean(filepath.Join(filepath.Dir(name), target))+ resolved = filepath.ToSlash(resolved)+ if resolved != "Claude.app" && !strings.HasPrefix(resolved, "Claude.app/") {+ return fmt.Errorf("Claude Desktop archive symlink %q escapes Claude.app", name)+ }+ return nil+}++func extractClaudeDesktopZipFile(file *zip.File, path string) error {+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return fmt.Errorf("create Claude Desktop archive directory: %w", err)+ }+ input, err := file.Open()+ if err != nil {+ return fmt.Errorf("open Claude Desktop archive file: %w", err)+ }+ output, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, file.Mode().Perm())+ if err != nil {+ input.Close()+ return fmt.Errorf("create Claude Desktop archive file: %w", err)+ }+ _, copyErr := io.Copy(output, input)+ inputErr := input.Close()+ outputErr := output.Close()+ if copyErr != nil {+ return fmt.Errorf("extract Claude Desktop archive file: %w", copyErr)+ }+ if inputErr != nil {+ return fmt.Errorf("close Claude Desktop archive file: %w", inputErr)+ }+ if outputErr != nil {+ return fmt.Errorf("close extracted Claude Desktop file: %w", outputErr)+ }+ return nil+}++func readClaudeDesktopZipFile(file *zip.File, limit int64) ([]byte, error) {+ reader, err := file.Open()+ if err != nil {+ return nil, err+ }+ defer reader.Close()+ data, err := io.ReadAll(io.LimitReader(reader, limit+1))+ if err != nil {+ return nil, err+ }+ if int64(len(data)) > limit {+ return nil, fmt.Errorf("archive entry exceeds %d bytes", limit)+ }+ return data, nil+}++func validateClaudeDesktopBundle(bundlePath string) error {+ info, err := os.Stat(bundlePath)+ if err != nil || !info.IsDir() {+ return errors.New("Claude Desktop archive does not contain Claude.app")+ }+ executable := filepath.Join(bundlePath, "Contents", "MacOS", "Claude")+ info, err = os.Stat(executable)+ if err != nil {+ return fmt.Errorf("Claude Desktop executable is missing: %w", err)+ }+ if !info.Mode().IsRegular() || info.Mode()&0o111 == 0 {+ return errors.New("Claude Desktop executable is not executable")+ }+ return nil+}++func verifyClaudeDesktopBundle(bundlePath string) error {+ if output, err := exec.Command("/usr/bin/codesign", "--verify", "--deep", "--strict", bundlePath).CombinedOutput(); err != nil {+ return fmt.Errorf("codesign verification failed: %w: %s", err, strings.TrimSpace(string(output)))+ }+ output, err := exec.Command("/usr/bin/codesign", "-d", "--verbose=4", bundlePath).CombinedOutput()+ if err != nil {+ return fmt.Errorf("read code signature: %w: %s", err, strings.TrimSpace(string(output)))+ }+ details := string(output)+ if !strings.Contains(details, "Identifier="+claudeDesktopBundleID) ||+ !strings.Contains(details, "TeamIdentifier="+claudeDesktopTeamID) {+ return fmt.Errorf("unexpected Claude Desktop signing identity")+ }+ return nil+}diff --git a/app/cmd/app/claude_desktop_installer_darwin_test.go b/app/cmd/app/claude_desktop_installer_darwin_test.gonew file mode 100644index 000000000..19aa973cc--- /dev/null+++ b/app/cmd/app/claude_desktop_installer_darwin_test.go@@ -0,0 +1,162 @@+//go:build darwin++package main++import (+ "archive/zip"+ "errors"+ "os"+ "path/filepath"+ "strings"+ "testing"+)++func TestInstallClaudeDesktopZip(t *testing.T) {+ archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{+ "Claude.app/": {directory: true},+ "Claude.app/Contents/": {directory: true},+ "Claude.app/Contents/MacOS/": {directory: true},+ "Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},+ "Claude.app/Contents/Resources/": {directory: true},+ "Claude.app/Contents/Resources/link": {body: "../MacOS/Claude", mode: os.ModeSymlink | 0o777},+ })+ destination := filepath.Join(t.TempDir(), "Applications", "Claude.app")+ var verified string+ installed, err := installClaudeDesktopZip(archive, []string{destination}, func(bundle string) error {+ verified = bundle+ return nil+ })+ if err != nil {+ t.Fatal(err)+ }+ if installed != destination || verified == "" {+ t.Fatalf("installed = %q, verified = %q", installed, verified)+ }+ info, err := os.Stat(filepath.Join(installed, "Contents", "MacOS", "Claude"))+ if err != nil {+ t.Fatal(err)+ }+ if info.Mode()&0o111 == 0 {+ t.Fatal("installed Claude executable is not executable")+ }+ if target, err := os.Readlink(filepath.Join(installed, "Contents", "Resources", "link")); err != nil || target != "../MacOS/Claude" {+ t.Fatalf("symlink target = %q, err = %v", target, err)+ }+}++func TestInstallClaudeDesktopZipRejectsUnsafeArchives(t *testing.T) {+ for _, test := range []struct {+ name string+ entries map[string]claudeDesktopTestZipEntry+ }{+ {name: "path traversal", entries: map[string]claudeDesktopTestZipEntry{"../Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755}}},+ {name: "unexpected root", entries: map[string]claudeDesktopTestZipEntry{"README": {body: "nope", mode: 0o644}}},+ {name: "escaping symlink", entries: map[string]claudeDesktopTestZipEntry{+ "Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},+ "Claude.app/escape": {body: "../../outside", mode: os.ModeSymlink | 0o777},+ }},+ } {+ t.Run(test.name, func(t *testing.T) {+ archive := writeClaudeDesktopTestZip(t, test.entries)+ destination := filepath.Join(t.TempDir(), "Claude.app")+ if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return nil }); err == nil {+ t.Fatal("installClaudeDesktopZip succeeded")+ }+ if _, err := os.Stat(destination); !errors.Is(err, os.ErrNotExist) {+ t.Fatalf("unsafe archive created destination: %v", err)+ }+ })+ }+}++func TestInstallClaudeDesktopZipVerifiesBeforeMove(t *testing.T) {+ archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{+ "Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},+ })+ destination := filepath.Join(t.TempDir(), "Claude.app")+ wantErr := errors.New("invalid signature")+ if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return wantErr }); !errors.Is(err, wantErr) {+ t.Fatalf("error = %v, want %v", err, wantErr)+ }+ if _, err := os.Stat(destination); !errors.Is(err, os.ErrNotExist) {+ t.Fatalf("invalid bundle created destination: %v", err)+ }+}++func TestInstallClaudeDesktopZipDoesNotOverwrite(t *testing.T) {+ archive := writeClaudeDesktopTestZip(t, map[string]claudeDesktopTestZipEntry{+ "Claude.app/Contents/MacOS/Claude": {body: "binary", mode: 0o755},+ })+ destination := filepath.Join(t.TempDir(), "Claude.app")+ if err := os.MkdirAll(destination, 0o755); err != nil {+ t.Fatal(err)+ }+ if _, err := installClaudeDesktopZip(archive, []string{destination}, func(string) error { return nil }); !errors.Is(err, errClaudeDesktopDestinationExists) {+ t.Fatalf("error = %v, want destination exists", err)+ }+}++func TestInstallClaudeDesktopZipRealArchive(t *testing.T) {+ archive := os.Getenv("OLLAMA_TEST_CLAUDE_DESKTOP_ZIP")+ if archive == "" {+ t.Skip("set OLLAMA_TEST_CLAUDE_DESKTOP_ZIP to a downloaded Claude Desktop ZIP")+ }+ destination := filepath.Join(t.TempDir(), "Applications", "Claude.app")+ installed, err := installClaudeDesktopZip(+ archive,+ []string{destination},+ verifyClaudeDesktopBundle,+ )+ if err != nil {+ t.Fatal(err)+ }+ if installed != destination {+ t.Fatalf("installed = %q, want %q", installed, destination)+ }+}++type claudeDesktopTestZipEntry struct {+ body string+ mode os.FileMode+ directory bool+}++func writeClaudeDesktopTestZip(t *testing.T, entries map[string]claudeDesktopTestZipEntry) string {+ t.Helper()+ path := filepath.Join(t.TempDir(), "Claude.zip")+ file, err := os.Create(path)+ if err != nil {+ t.Fatal(err)+ }+ writer := zip.NewWriter(file)+ for name, entry := range entries {+ header := &zip.FileHeader{Name: name, Method: zip.Deflate}+ if entry.directory {+ header.SetMode(os.ModeDir | 0o755)+ } else {+ header.SetMode(entry.mode)+ }+ item, err := writer.CreateHeader(header)+ if err != nil {+ t.Fatal(err)+ }+ if _, err := item.Write([]byte(entry.body)); err != nil {+ t.Fatal(err)+ }+ }+ if err := writer.Close(); err != nil {+ t.Fatal(err)+ }+ if err := file.Close(); err != nil {+ t.Fatal(err)+ }+ return path+}++func TestSafeClaudeDesktopArchivePath(t *testing.T) {+ for _, name := range []string{"Claude.app", "Claude.app/Contents/MacOS/Claude"} {+ if got, err := safeClaudeDesktopArchivePath(name); err != nil || got != strings.TrimSuffix(name, "/") {+ t.Fatalf("safeClaudeDesktopArchivePath(%q) = %q, %v", name, got, err)+ }+ }+}diff --git a/app/cmd/app/claude_desktop_status.go b/app/cmd/app/claude_desktop_status.goindex fd82bbdc9..36b512e0c 100644--- a/app/cmd/app/claude_desktop_status.go+++ b/app/cmd/app/claude_desktop_status.go@@ -2,6 +2,8 @@package main+import "github.com/ollama/ollama/internal/proxy"+type claudeDesktopInstallResult stringconst (@@ -11,11 +13,29 @@ const ()type claudeDesktopStatus struct {- Installed bool `json:"installed"`- Configured bool `json:"configured"`- Connected bool `json:"connected"`- Running bool `json:"running"`- StartFailed bool `json:"startFailed"`+ Supported bool `json:"supported"`+ Used bool `json:"used"`+ Installed bool `json:"installed"`+ Configured bool `json:"configured"`+ Connected bool `json:"connected"`+ Running bool `json:"running"`+ StartFailed bool `json:"startFailed"`+ PortConflict bool `json:"portConflict"`+ GatewayPort int `json:"gatewayPort,omitempty"`+ Error string `json:"error,omitempty"`+ ModelSource string `json:"modelSource,omitempty"`+ Models []claudeDesktopModelStatus `json:"models,omitempty"`+}++type claudeDesktopModelStatus struct {+ Name string `json:"name"`+ DisplayName string `json:"displayName"`+ Description string `json:"description,omitempty"`+ Cloud bool `json:"cloud"`+ Selected bool `json:"selected"`+ Availability proxy.ClaudeDesktopAvailability `json:"availability"`+ Reason proxy.ClaudeDesktopAccessReason `json:"reason,omitempty"`+ RequiredPlan string `json:"requiredPlan,omitempty"`}type claudeDesktopActionResult struct {diff --git a/app/store/database.go b/app/store/database.goindex b8b166588..cfa9136a9 100644--- a/app/store/database.go+++ b/app/store/database.go@@ -14,7 +14,7 @@ import (// currentSchemaVersion defines the current database schema version.// Increment this when making schema changes that require migrations.-const currentSchemaVersion = 17+const currentSchemaVersion = 18// database wraps the SQLite connection.// SQLite handles its own locking for concurrent access:@@ -89,6 +89,7 @@ func (db *database) init() error {cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0,remote TEXT NOT NULL DEFAULT '', -- deprecatedauto_update_enabled BOOLEAN NOT NULL DEFAULT 1,+ claude_desktop_used BOOLEAN NOT NULL DEFAULT 0,schema_version INTEGER NOT NULL DEFAULT %d);@@ -278,6 +279,12 @@ func (db *database) migrate() error {return fmt.Errorf("migrate v16 to v17: %w", err)}version = 17+ case 17:+ // Remember that Claude Desktop has been connected at least once.+ if err := db.migrateV17ToV18(); err != nil {+ return fmt.Errorf("migrate v17 to v18: %w", err)+ }+ version = 18default:// If we have a version we don't recognize, just set it to current// This might happen during development@@ -564,6 +571,21 @@ func (db *database) migrateV16ToV17() error {return nil}+// migrateV17ToV18 adds durable Claude Desktop integration history.+func (db *database) migrateV17ToV18() error {+ _, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN claude_desktop_used BOOLEAN NOT NULL DEFAULT 0`)+ if err != nil && !duplicateColumnError(err) {+ return fmt.Errorf("add claude_desktop_used column: %w", err)+ }++ _, err = db.conn.Exec(`UPDATE settings SET schema_version = 18`)+ if err != nil {+ return fmt.Errorf("update schema version: %w", err)+ }++ return nil+}+// cleanupOrphanedData removes orphaned records that may exist due to the foreign key bugfunc (db *database) cleanupOrphanedData() error {_, err := db.conn.Exec(`@@ -1212,9 +1234,9 @@ func (db *database) getSettings() (Settings, error) {var s Settingserr := db.conn.QueryRow(`- SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, last_home_view, onboarding_version, think_enabled, think_level, auto_update_enabled+ SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, last_home_view, onboarding_version, think_enabled, think_level, auto_update_enabled, claude_desktop_usedFROM settings- `).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.LastHomeView, &s.OnboardingVersion, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled)+ `).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.LastHomeView, &s.OnboardingVersion, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled, &s.ClaudeDesktopUsed)if err != nil {return Settings{}, fmt.Errorf("get settings: %w", err)}@@ -1230,8 +1252,8 @@ func (db *database) setSettings(s Settings) error {_, err := db.conn.Exec(`UPDATE settings- SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, last_home_view = ?, onboarding_version = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?- `, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, lastHomeView, s.OnboardingVersion, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled)+ SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, last_home_view = ?, onboarding_version = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?, claude_desktop_used = ?+ `, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, lastHomeView, s.OnboardingVersion, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled, s.ClaudeDesktopUsed)if err != nil {return fmt.Errorf("set settings: %w", err)}diff --git a/app/store/database_test.go b/app/store/database_test.goindex d4c75a231..a1bbf4fbd 100644--- a/app/store/database_test.go+++ b/app/store/database_test.go@@ -221,6 +221,41 @@ func TestOnboardingVersionDefaultsAndMigration(t *testing.T) {})}+func TestClaudeDesktopUsedDefaultsAndMigration(t *testing.T) {+ dbPath := filepath.Join(t.TempDir(), "claude-history.db")+ db, err := newDatabase(dbPath)+ if err != nil {+ t.Fatalf("failed to create database: %v", err)+ }+ defer db.Close()++ settings, err := db.getSettings()+ if err != nil {+ t.Fatalf("failed to read settings: %v", err)+ }+ if settings.ClaudeDesktopUsed {+ t.Fatal("expected fresh installs to have no Claude Desktop history")+ }++ if _, err := db.conn.Exec(`+ ALTER TABLE settings DROP COLUMN claude_desktop_used;+ UPDATE settings SET schema_version = 17;+ `); err != nil {+ t.Fatalf("failed to seed v17 settings row: %v", err)+ }+ if err := db.migrate(); err != nil {+ t.Fatalf("migration from v17 to v18 failed: %v", err)+ }++ settings, err = db.getSettings()+ if err != nil {+ t.Fatalf("failed to read migrated settings: %v", err)+ }+ if settings.ClaudeDesktopUsed {+ t.Fatal("expected existing installs to start with no inferred Claude Desktop history")+ }+}+func TestChatDeletionWithCascade(t *testing.T) {t.Run("chat deletion cascades to related messages", func(t *testing.T) {tmpDir := t.TempDir()diff --git a/app/store/store.go b/app/store/store.goindex 490eb8a6c..18020b604 100644--- a/app/store/store.go+++ b/app/store/store.go@@ -175,6 +175,9 @@ type Settings struct {// AutoUpdateEnabled indicates if automatic updates should be downloadedAutoUpdateEnabled bool++ // ClaudeDesktopUsed records whether Claude Desktop has ever been connected through Ollama.+ ClaudeDesktopUsed bool}// Keep in sync with CURRENT_ONBOARDING_VERSION in app/ui/app/src/lib/onboarding.ts.diff --git a/app/store/store_test.go b/app/store/store_test.goindex 3d27cfa88..c394d3d55 100644--- a/app/store/store_test.go+++ b/app/store/store_test.go@@ -253,6 +253,32 @@ func TestOnboardingVersionRoundTrip(t *testing.T) {}}+func TestClaudeDesktopUsedRoundTrip(t *testing.T) {+ s, cleanup := setupTestStore(t)+ defer cleanup()++ settings, err := s.Settings()+ if err != nil {+ t.Fatal(err)+ }+ if settings.ClaudeDesktopUsed {+ t.Fatal("expected Claude Desktop history to be false by default")+ }++ settings.ClaudeDesktopUsed = true+ if err := s.SetSettings(settings); err != nil {+ t.Fatal(err)+ }++ loaded, err := s.Settings()+ if err != nil {+ t.Fatal(err)+ }+ if !loaded.ClaudeDesktopUsed {+ t.Fatal("expected Claude Desktop history to persist")+ }+}+// setupTestStore creates a temporary store for testingfunc setupTestStore(t *testing.T) (*Store, func()) {t.Helper()diff --git a/app/ui/app/codegen/gotypes.gen.ts b/app/ui/app/codegen/gotypes.gen.tsindex 6db6fd91a..1860e90b0 100644--- a/app/ui/app/codegen/gotypes.gen.ts+++ b/app/ui/app/codegen/gotypes.gen.ts@@ -417,6 +417,7 @@ export class Settings {LastHomeView: string;OnboardingVersion: number;AutoUpdateEnabled: boolean;+ ClaudeDesktopUsed: boolean;constructor(source: any = {}) {if ('string' === typeof source) source = JSON.parse(source);@@ -437,6 +438,7 @@ export class Settings {this.LastHomeView = source["LastHomeView"];this.OnboardingVersion = source["OnboardingVersion"];this.AutoUpdateEnabled = source["AutoUpdateEnabled"];+ this.ClaudeDesktopUsed = source["ClaudeDesktopUsed"];}}export class SettingsResponse {diff --git a/app/ui/app/src/api.test.ts b/app/ui/app/src/api.test.tsindex 202886316..5caba04b4 100644--- a/app/ui/app/src/api.test.ts+++ b/app/ui/app/src/api.test.ts@@ -1,5 +1,14 @@import { afterEach, describe, expect, it, vi } from "vitest";-import { fetchConnectUrl, getIntegrationStatuses } from "./api";+const { listModels } = vi.hoisted(() => ({ listModels: vi.fn() }));+vi.mock("./lib/ollama-client", () => ({+ ollamaClient: { list: listModels },+}));++import {+ fetchConnectUrl,+ getClaudeDesktopAvailableModels,+ getIntegrationStatuses,+} from "./api";describe("fetchConnectUrl", () => {afterEach(() => {@@ -72,3 +81,61 @@ describe("getIntegrationStatuses", () => {);});});++describe("getClaudeDesktopAvailableModels", () => {+ afterEach(() => {+ listModels.mockReset();+ vi.unstubAllGlobals();+ vi.restoreAllMocks();+ });++ it("returns installed local models while pruning remote entries", async () => {+ listModels.mockResolvedValue({+ models: [+ { name: "llama3.2:latest", digest: "local" },+ {+ name: "remote-placeholder",+ digest: "remote",+ remote_host: "https://ollama.com",+ },+ ],+ });+ const fetch = vi.fn();+ vi.stubGlobal("fetch", fetch);++ const models = await getClaudeDesktopAvailableModels();++ expect(models.map((model) => model.model)).toEqual(["llama3.2"]);+ expect(fetch).not.toHaveBeenCalled();+ });++ it("does not request cloud models when they are unavailable to the user", async () => {+ listModels.mockResolvedValue({+ models: [+ { name: "qwen3:8b", digest: "local" },+ { name: "deepseek-v4-flash:cloud", digest: "cached-cloud" },+ { name: "gemma4:31b-cloud", digest: "legacy-cached-cloud" },+ ],+ });+ const fetch = vi.fn();+ vi.stubGlobal("fetch", fetch);++ const models = await getClaudeDesktopAvailableModels();++ expect(models.map((model) => model.model)).toEqual(["qwen3:8b"]);+ expect(fetch).not.toHaveBeenCalled();+ });++ it("does not use the global cloud model list", async () => {+ listModels.mockResolvedValue({+ models: [{ name: "qwen3:8b", digest: "local" }],+ });+ const fetch = vi.fn().mockRejectedValue(new Error("offline"));+ vi.stubGlobal("fetch", fetch);++ const models = await getClaudeDesktopAvailableModels();++ expect(models.map((model) => model.model)).toEqual(["qwen3:8b"]);+ expect(fetch).not.toHaveBeenCalled();+ });+});diff --git a/app/ui/app/src/api.ts b/app/ui/app/src/api.tsindex 5459e2d4b..c4fe644df 100644--- a/app/ui/app/src/api.ts+++ b/app/ui/app/src/api.ts@@ -196,6 +196,53 @@ export async function getModels(query?: string): Promise<Model[]> {}}+export async function getClaudeDesktopAvailableModels(): Promise<Model[]> {+ try {+ const { models: modelsResponse } = await ollama.list();++ const seen = new Set<string>();+ return modelsResponse+ .filter((model: ModelResponse) => {+ const response = model as ModelResponse & {+ remote_model?: string;+ remote_host?: string;+ };+ const name = model.name.replace(/:latest$/, "");+ return (+ !response.remote_model &&+ !response.remote_host &&+ !name.endsWith("cloud")+ );+ })+ .filter((model: ModelResponse) => {+ const base = model.name.replace(/:latest$/, "");+ if (!base || seen.has(base)) return false;++ const families = model.details?.families;+ const supported =+ !families ||+ families.length === 0 ||+ !families.every((family: string) =>+ family.toLowerCase().includes("bert"),+ );+ if (supported) seen.add(base);+ return supported;+ })+ .map(+ (model: ModelResponse) =>+ new Model({+ model: model.name.replace(/:latest$/, ""),+ digest: model.digest,+ modified_at: model.modified_at+ ? new Date(model.modified_at)+ : undefined,+ }),+ );+ } catch (err) {+ throw new Error(`Failed to fetch Ollama models: ${err}`);+ }+}+export async function getModelCapabilities(modelName: string,): Promise<ModelCapabilitiesResponse> {diff --git a/app/ui/app/src/components/ClaudeDesktopModelsSettings.test.tsx b/app/ui/app/src/components/ClaudeDesktopModelsSettings.test.tsxnew file mode 100644index 000000000..1c68cd56d--- /dev/null+++ b/app/ui/app/src/components/ClaudeDesktopModelsSettings.test.tsx@@ -0,0 +1,424 @@+import { renderToStaticMarkup } from "react-dom/server";+import { describe, expect, it } from "vitest";+import { ClaudeDesktopModelsSettings } from "./ClaudeDesktopModelsSettings";++describe("ClaudeDesktopModelsSettings", () => {+ it("shows Claude recommendations and an installed-model search in Settings", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialLocalModels={["llama3.2", "qwen3:8b"]}+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "deepseek-v4-flash:cloud",+ displayName: "deepseek-v4-flash:cloud",+ cloud: true,+ selected: false,+ },+ ],+ }}+ />,+ );++ expect(html).toContain(">Claude<");+ expect(html).toContain(">Apps<");+ expect(html).toContain('id="apps-settings-heading"');+ expect(html).toContain('src="/launch-icons/claude.svg"');+ expect(html).not.toContain("Models in Claude");+ expect(html).toContain("glm-5.2:cloud");+ expect(html).toContain("deepseek-v4-flash:cloud");+ expect(html).toContain("Search Ollama models");+ expect(html).not.toContain("Add any Ollama model");+ expect(html).toContain("Restart Claude");+ expect((html.match(/checked=""/g) ?? []).length).toBe(2);+ });++ it("does not show the invalid Ollama Cloud sentinel", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "user",+ models: [+ {+ name: "Ollama Cloud",+ displayName: "Ollama Cloud",+ selected: true,+ },+ {+ name: "qwen3:8b",+ displayName: "qwen3:8b",+ selected: true,+ },+ ],+ }}+ />,+ );++ expect(html).not.toContain("Ollama Cloud");+ expect(html).toContain("qwen3:8b");+ });++ it("labels the built-in fallback without exposing MLX", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "fallback",+ models: [+ {+ name: "deepseek-v4-flash:0731:cloud",+ displayName: "deepseek-v4-flash:0731:cloud",+ cloud: true,+ selected: true,+ },+ ],+ }}+ />,+ );++ expect(html).toContain("Built-in defaults");+ expect(html).toContain("deepseek-v4-flash:0731:cloud");+ expect(html).not.toContain("MLX");+ });++ it("prevents a sixth selection when the literal Claude slots are full", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ maxModels: 5,+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "kimi-k3:cloud",+ displayName: "kimi-k3:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "deepseek-v4-pro:cloud",+ displayName: "deepseek-v4-pro:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "deepseek-v4-flash:cloud",+ displayName: "deepseek-v4-flash:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "gemma4:26b:cloud",+ displayName: "gemma4:26b:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "qwen3:8b",+ displayName: "qwen3:8b",+ selected: false,+ },+ ],+ }}+ />,+ );++ const index = html.indexOf(">qwen3:8b</span>");+ expect(index).toBeGreaterThan(-1);+ const label = html.slice(html.lastIndexOf("<label", index), index);+ expect(label).toContain("disabled");+ expect((html.match(/disabled=""/g) ?? []).length).toBe(1);+ expect(html).toContain(+ "Claude supports up to 5 models. Deselect one to add another.",+ );+ });++ it("honors a smaller maxModels limit from the status", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ maxModels: 1,+ models: [+ {+ name: "kimi-k3:cloud",+ displayName: "kimi-k3:cloud",+ cloud: true,+ selected: true,+ },+ {+ name: "qwen3:8b",+ displayName: "qwen3:8b",+ selected: false,+ },+ ],+ }}+ />,+ );++ const index = html.indexOf(">qwen3:8b</span>");+ expect(index).toBeGreaterThan(-1);+ const label = html.slice(html.lastIndexOf("<label", index), index);+ expect(label).toContain("disabled");+ });++ it("hides recommendation and selected cloud models when cloud is disabled", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialLocalModels={["qwen3:8b"]}+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: false,+ running: false,+ startFailed: true,+ portConflict: false,+ error: "Cloud models are off. Select an installed model in Settings.",+ modelSource: "endpoint",+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ cloud: true,+ selected: true,+ availability: "unavailable",+ reason: "cloud_off",+ },+ ],+ }}+ />,+ );++ expect(html).not.toContain("glm-5.2:cloud");+ expect(html).toContain("Search Ollama models");+ expect(html).toContain(+ "Cloud models are off. Select an installed model in Settings.",+ );+ expect(html).not.toContain(+ "These models will be available when Claude starts.",+ );+ expect(html).not.toContain("text-red");+ });++ it("shows account requirements and prevents selecting unavailable models", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ cloud: true,+ selected: false,+ availability: "unavailable",+ reason: "upgrade_required",+ requiredPlan: "pro",+ },+ {+ name: "gemma4:31b-cloud",+ displayName: "gemma4:31b-cloud",+ cloud: true,+ selected: true,+ availability: "available",+ requiredPlan: "free",+ },+ ],+ }}+ />,+ );++ expect(html).toContain("pro plan required");+ const index = html.indexOf(">glm-5.2:cloud</span>");+ const label = html.slice(html.lastIndexOf("<label", index), index);+ expect(label).toContain("disabled");+ expect(html).toContain("gemma4:31b-cloud");+ });++ it("replaces paid defaults with the available free recommendation", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: false,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ models: [+ "glm-5.2:cloud",+ "kimi-k3:cloud",+ "deepseek-v4-pro:cloud",+ "deepseek-v4-flash:cloud",+ ]+ .map((name) => ({+ name,+ displayName: name,+ cloud: true,+ selected: true,+ availability: "unavailable" as const,+ reason: "upgrade_required" as const,+ requiredPlan: "pro",+ }))+ .concat([+ {+ name: "gemma4:31b-cloud",+ displayName: "gemma4:31b-cloud",+ cloud: true,+ selected: false,+ availability: "available" as const,+ requiredPlan: "free",+ },+ ]),+ }}+ />,+ );++ expect((html.match(/>pro plan required<\/span>/g) ?? []).length).toBe(4);+ expect((html.match(/checked=""/g) ?? []).length).toBe(1);+ const gemmaIndex = html.indexOf(">gemma4:31b-cloud</span>");+ const gemmaInput = html.slice(+ html.lastIndexOf("<input", gemmaIndex),+ gemmaIndex,+ );+ expect(gemmaInput).toContain('checked=""');+ expect(html).toContain("Start Claude");+ });++ it("does not restart Claude when every selected model is unavailable", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ cloud: true,+ selected: true,+ availability: "unavailable",+ reason: "upgrade_required",+ requiredPlan: "pro",+ },+ ],+ }}+ />,+ );++ expect(html).toContain("Select a model available to your account.");+ const button = html.slice(html.lastIndexOf("<button"));+ expect(button).toContain("disabled");+ });++ it("remains visible after Claude has been disconnected", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: false,+ running: false,+ startFailed: false,+ portConflict: false,+ modelSource: "user",+ models: [+ {+ name: "qwen3:8b",+ displayName: "qwen3:8b",+ selected: true,+ },+ ],+ }}+ />,+ );++ expect(html).toContain(">Claude<");+ expect(html).toContain("qwen3:8b");+ expect(html).toContain(+ "These models will be available when Claude starts.",+ );+ expect(html).toContain("Start Claude");+ });++ it("stays hidden until Claude has been enabled once", () => {+ const html = renderToStaticMarkup(+ <ClaudeDesktopModelsSettings+ initialStatus={{+ supported: true,+ used: false,+ installed: true,+ connected: false,+ running: false,+ startFailed: false,+ portConflict: false,+ }}+ />,+ );++ expect(html).toBe("");+ });+});diff --git a/app/ui/app/src/components/ClaudeDesktopModelsSettings.tsx b/app/ui/app/src/components/ClaudeDesktopModelsSettings.tsxnew file mode 100644index 000000000..8e1bd9848--- /dev/null+++ b/app/ui/app/src/components/ClaudeDesktopModelsSettings.tsx@@ -0,0 +1,420 @@+import { getClaudeDesktopAvailableModels } from "@/api";+import { Button } from "@/components/ui/button";+import { Input } from "@/components/ui/input";+import {+ addClaudeModelSelection,+ claudeDesktopRecoveryMessage,+ claudeDesktopMaxModels,+ claudeDesktopMaxModelsMessage,+ claudeDesktopUsableSelection,+} from "@/lib/claudeDesktop";+import type {+ ClaudeDesktopModelStatus,+ ClaudeDesktopStatus,+} from "@/types/webview";+import { ArrowPathIcon } from "@heroicons/react/20/solid";+import { useCallback, useEffect, useMemo, useRef, useState } from "react";++interface ClaudeDesktopModelsSettingsProps {+ initialStatus?: ClaudeDesktopStatus;+ initialLocalModels?: string[];+}++function isInvalidModelName(name: string): boolean {+ const normalized = name.trim().toLowerCase().replace(/[-:]+/g, " ");+ return normalized === "ollama cloud";+}++function visibleModels(+ status: ClaudeDesktopStatus,+): ClaudeDesktopModelStatus[] {+ return (status.models ?? []).filter(+ (model) => !isInvalidModelName(model.name) && model.reason !== "cloud_off",+ );+}++function selectedModelNames(status: ClaudeDesktopStatus): string[] {+ return claudeDesktopUsableSelection(+ visibleModels(status),+ status.modelSource !== "user",+ claudeDesktopMaxModels(status),+ );+}++function modelAccessLabel(model: ClaudeDesktopModelStatus): string | null {+ switch (model.reason) {+ case "sign_in_required":+ return "Sign in required";+ case "upgrade_required":+ return model.requiredPlan+ ? `${model.requiredPlan} plan required`+ : "Upgrade required";+ case "verification_unavailable":+ return "Access unavailable";+ case "model_not_installed":+ return "Not installed";+ default:+ return null;+ }+}++function explicitCloudName(name: string): string {+ return name.endsWith(":cloud") ? name : `${name}:cloud`;+}++export function ClaudeDesktopModelsSettings({+ initialStatus,+ initialLocalModels,+}: ClaudeDesktopModelsSettingsProps) {+ const [status, setStatus] = useState<ClaudeDesktopStatus | null>(+ initialStatus ?? null,+ );+ const [models, setModels] = useState<ClaudeDesktopModelStatus[]>(() =>+ initialStatus ? visibleModels(initialStatus) : [],+ );+ const [selection, setSelection] = useState<string[]>(() =>+ initialStatus ? selectedModelNames(initialStatus) : [],+ );+ const [localModels, setLocalModels] = useState<string[]>(+ initialLocalModels ?? [],+ );+ const [searchQuery, setSearchQuery] = useState("");+ const [pickerOpen, setPickerOpen] = useState(false);+ const [modelsLoading, setModelsLoading] = useState(false);+ const [error, setError] = useState<string | null>(null);+ const [restarting, setRestarting] = useState(false);+ const pickerRef = useRef<HTMLDivElement>(null);++ const applyStatus = useCallback((next: ClaudeDesktopStatus) => {+ setStatus(next);+ setModels(visibleModels(next));+ setSelection(selectedModelNames(next));+ setError(null);+ }, []);++ const refreshStatus = useCallback(async () => {+ if (!window.getClaudeDesktopStatus) return;+ try {+ applyStatus(await window.getClaudeDesktopStatus());+ } catch {+ setError("Ollama could not read the Claude connection status.");+ }+ }, [applyStatus]);++ useEffect(() => {+ if (!initialStatus) void refreshStatus();+ const handleFocus = () => void refreshStatus();+ window.addEventListener("focus", handleFocus);+ return () => window.removeEventListener("focus", handleFocus);+ }, [initialStatus, refreshStatus]);++ useEffect(() => {+ if (!status) return;+ setModels(visibleModels(status));+ setSelection(selectedModelNames(status));+ }, [status]);++ useEffect(() => {+ if (initialLocalModels || !status?.used) return;+ let cancelled = false;+ setModelsLoading(true);+ void getClaudeDesktopAvailableModels()+ .then((installed) => {+ if (!cancelled) {+ setLocalModels(installed.map((model) => model.model));+ }+ })+ .catch(() => {+ if (!cancelled) setError("Ollama could not load your models.");+ })+ .finally(() => {+ if (!cancelled) setModelsLoading(false);+ });+ return () => {+ cancelled = true;+ };+ }, [initialLocalModels, status?.used]);++ useEffect(() => {+ const handleClickOutside = (event: MouseEvent) => {+ if (+ pickerRef.current &&+ !pickerRef.current.contains(event.target as Node)+ ) {+ setPickerOpen(false);+ }+ };+ document.addEventListener("mousedown", handleClickOutside);+ return () => document.removeEventListener("mousedown", handleClickOutside);+ }, []);++ const matchingLocalModels = useMemo(() => {+ const current = new Set(+ models.map((model) =>+ model.cloud ? explicitCloudName(model.name) : model.name,+ ),+ );+ const query = searchQuery.trim().toLowerCase();+ return localModels+ .filter(+ (name) =>+ !current.has(name) &&+ !isInvalidModelName(name) &&+ (!query || name.toLowerCase().includes(query)),+ )+ .sort((left, right) => left.localeCompare(right));+ }, [localModels, models, searchQuery]);++ const toggleModel = (name: string) => {+ setError(null);+ setSelection((current) => {+ if (!current.includes(name)) {+ const result = addClaudeModelSelection(+ current,+ name,+ claudeDesktopMaxModels(status),+ );+ if (result.error) {+ setError(result.error);+ return current;+ }+ return result.selection;+ }+ if (current.length === 1) {+ setError("Select at least one model for Claude.");+ return current;+ }+ return current.filter((model) => model !== name);+ });+ };++ const addLocalModel = (name: string) => {+ const maxModels = claudeDesktopMaxModels(status);+ const result = addClaudeModelSelection(selection, name, maxModels);+ if (result.error) {+ setError(result.error);+ return;+ }+ const cloud = name.endsWith(":cloud");+ setModels((current) => [+ ...current,+ {+ name,+ displayName: name,+ cloud,+ selected: true,+ availability: "available",+ },+ ]);+ setSelection(result.selection);+ setSearchQuery("");+ setPickerOpen(false);+ setError(null);+ };++ const hasAvailableSelection = selection.some((name) => {+ const model = models.find((candidate) => candidate.name === name);+ return !model?.availability || model.availability === "available";+ });++ const restartClaude = async () => {+ if (!window.restartClaudeDesktop) {+ setError("Claude restart is available in the Ollama macOS app.");+ return;+ }+ if (selection.length === 0) {+ setError("Select at least one model for Claude.");+ return;+ }+ if (!hasAvailableSelection) {+ setError("Select a model available to your account.");+ return;+ }+ if (+ status?.running &&+ !window.confirm(+ "Restart Claude Desktop to update its models? Any running task will stop.",+ )+ ) {+ return;+ }++ setError(null);+ setRestarting(true);+ try {+ const result = await window.restartClaudeDesktop(selection);+ applyStatus(result.status);+ if (result.error) setError(result.error);+ } catch {+ setError("Ollama could not restart Claude.");+ } finally {+ setRestarting(false);+ }+ };++ if (!status?.supported || !status.used) {+ return null;+ }++ const maxModels = claudeDesktopMaxModels(status);+ const selectionFull = selection.length >= maxModels;+ const guidance =+ claudeDesktopRecoveryMessage(status.error, error) ??+ (!hasAvailableSelection && models.length > 0+ ? "Select a model available to your account."+ : selectionFull+ ? claudeDesktopMaxModelsMessage(maxModels)+ : status.connected+ ? "Restart Claude to refresh its model list."+ : "These models will be available when Claude starts.");++ return (+ <section aria-labelledby="apps-settings-heading" className="space-y-2">+ <h2+ id="apps-settings-heading"+ className="px-1 text-xs font-medium uppercase tracking-wider text-neutral-400 dark:text-neutral-500"+ >+ Apps+ </h2>+ <div+ aria-labelledby="claude-models-settings-heading"+ className="overflow-visible rounded-xl bg-white p-4 dark:bg-neutral-800"+ >+ <div className="flex items-start space-x-3">+ <img+ src="/launch-icons/claude.svg"+ alt=""+ className="mt-0.5 h-5 w-5 flex-shrink-0"+ />+ <div className="min-w-0 flex-1">+ <div className="flex items-center justify-between gap-3">+ <h2+ id="claude-models-settings-heading"+ className="text-sm font-medium text-neutral-900 dark:text-white"+ >+ Claude+ </h2>+ {status.modelSource === "fallback" && models.length > 0 && (+ <span className="text-xs text-neutral-400">+ Built-in defaults+ </span>+ )}+ </div>++ <div className="mt-3 grid grid-cols-2 gap-x-5 gap-y-2 max-[850px]:grid-cols-1">+ {models.map((model) => {+ const selected = selection.includes(model.name);+ const accessLabel = modelAccessLabel(model);+ const unavailable =+ model.availability !== undefined &&+ model.availability !== "available";+ return (+ <label+ key={model.name}+ className="flex min-w-0 cursor-pointer items-center gap-2 rounded-md py-1 text-sm text-neutral-600 dark:text-neutral-300"+ title={accessLabel ?? model.description}+ >+ <input+ type="checkbox"+ checked={selected}+ disabled={+ restarting ||+ (!selected && (selectionFull || unavailable))+ }+ onChange={() => toggleModel(model.name)}+ className="h-4 w-4 rounded border-neutral-300 accent-neutral-900 dark:border-neutral-600 dark:accent-white"+ />+ <span className="truncate">{model.displayName}</span>+ {accessLabel && (+ <span className="flex-shrink-0 text-xs text-neutral-400">+ {accessLabel}+ </span>+ )}+ </label>+ );+ })}+ </div>++ <div ref={pickerRef} className="relative mt-3">+ <Input+ type="search"+ value={searchQuery}+ onFocus={() => setPickerOpen(true)}+ onChange={(event) => {+ setSearchQuery(event.target.value);+ setPickerOpen(true);+ }}+ placeholder="Search Ollama models"+ aria-label="Search Ollama models"+ aria-expanded={pickerOpen}+ aria-controls="claude-local-models"+ disabled={restarting}+ autoComplete="off"+ />+ {pickerOpen && (+ <div+ id="claude-local-models"+ className="absolute z-20 mt-1 max-h-52 w-full overflow-y-auto rounded-lg border border-neutral-200 bg-white p-1 shadow-lg dark:border-neutral-600 dark:bg-neutral-800"+ >+ {modelsLoading ? (+ <p className="px-3 py-2 text-sm text-neutral-400">+ Loading models…+ </p>+ ) : selectionFull ? (+ <p className="px-3 py-2 text-sm text-neutral-400">+ {claudeDesktopMaxModelsMessage(maxModels)}+ </p>+ ) : matchingLocalModels.length > 0 ? (+ matchingLocalModels.map((name) => (+ <button+ key={name}+ type="button"+ onClick={() => addLocalModel(name)}+ className="block w-full rounded-md px-3 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:text-neutral-200 dark:hover:bg-neutral-700"+ >+ {name}+ </button>+ ))+ ) : (+ <p className="px-3 py-2 text-sm text-neutral-400">+ No models found.+ </p>+ )}+ </div>+ )}+ </div>++ <div className="mt-3 flex items-center justify-between gap-4 max-sm:flex-col max-sm:items-stretch">+ <p+ role={error || status.error ? "alert" : undefined}+ className="text-xs leading-5 text-neutral-500 dark:text-neutral-400"+ >+ {guidance}+ </p>+ <Button+ type="button"+ color="white"+ onClick={restartClaude}+ disabled={+ restarting || selection.length === 0 || !hasAvailableSelection+ }+ className="flex-shrink-0 max-sm:w-full"+ >+ {restarting && (+ <ArrowPathIcon data-slot="icon" className="animate-spin" />+ )}+ {restarting+ ? status.connected+ ? "Restarting…"+ : "Starting…"+ : status.connected+ ? "Restart Claude"+ : "Start Claude"}+ </Button>+ </div>+ </div>+ </div>+ </div>+ </section>+ );+}diff --git a/app/ui/app/src/components/Onboarding.test.tsx b/app/ui/app/src/components/Onboarding.test.tsxindex 066089950..1daeb42dd 100644--- a/app/ui/app/src/components/Onboarding.test.tsx+++ b/app/ui/app/src/components/Onboarding.test.tsx@@ -115,11 +115,13 @@ describe("Onboarding", () => {it("finishes Claude connection states from the native status hook", () => {const status = {+ supported: true,installed: true,configured: true,connected: true,running: false,startFailed: false,+ portConflict: false,};expect(isClaudeConnectionComplete(true, status)).toBe(true);@@ -136,6 +138,9 @@ describe("Onboarding", () => {connected: false,}),).toBe(true);+ expect(+ isClaudeConnectionComplete(false, { ...status, connected: false }),+ ).toBe(false);});it("bounds the Claude installer wait", () => {@@ -199,78 +204,127 @@ describe("Onboarding", () => {name: "Claude",description: "Use Ollama models in Claude Desktop",installed: true,+ action: "connect",},{id: "claude",name: "Claude Code",description: "Anthropic's coding tool with subagents",+ installed: true,+ action: "copy",command: "ollama launch claude",},{id: "codex",name: "Codex",description: "OpenAI's open-source coding agent",+ installed: true,+ action: "copy",command: "ollama launch codex",},{id: "openclaw",name: "OpenClaw",description: "Personal AI with 100+ skills",+ installed: true,+ action: "copy",command: "ollama launch openclaw",},{id: "opencode",name: "OpenCode",description: "Anomaly's open-source coding agent",+ installed: false,+ action: "copy",command: "ollama launch opencode",},{id: "droid",name: "Droid",description: "AI software engineering agent",+ installed: false,+ action: "copy",command: "ollama launch droid",},{id: "terminal",name: "Terminal",description: "Run local models from your terminal",+ action: "copy",command: "ollama",},];const html = renderToStaticMarkup(- <ConnectAppsScreen initialIntegrations={integrations} />,+ <ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}+ initialIntegrations={integrations}+ />,);+ expect(html).not.toContain(+ "Connect Claude, or copy a command to run in your terminal.",+ );+ expect(html).toContain("Claude");+ expect(html).toContain("Use Ollama models in Claude Desktop");+ expect(html).toContain("Claude Code");+ expect(html).not.toContain("Search apps");+ expect(html).not.toContain('type="search"');+ expect(html).toContain("Application");expect(html).toContain('id="applications-heading"');expect(html).toContain('id="terminal-heading"');+ expect(html).not.toContain("Ready to launch");+ expect(html).not.toContain('id="claude-apps-heading"');expect(html.indexOf("Application")).toBeLessThan(html.indexOf("Use Ollama models in Claude Desktop"),);+ expect(html).not.toContain(">Command</th>");+ expect(html).toContain("ollama launch claude");+ expect(html).not.toContain("Installed");+ expect(html).not.toContain("Not installed");expect(html).toContain('aria-label="Connect Claude"');expect(html).toContain('role="switch"');expect(html).toContain('aria-checked="false"');expect(html).not.toContain("Inactive");+ expect(html).not.toContain("Download & connect");expect(html).not.toContain("Active");+ expect(html).toContain("bg-transparent");expect(html).toContain('aria-label="Copy OpenCode command"');expect(html).toContain('aria-label="Copy Terminal command"');+ expect(html).not.toContain(">Copy command</button>");expect(html).not.toContain("ChatGPT");+ expect(html).toContain("OpenCode");+ expect(html).toContain("Terminal");expect(html).toContain('aria-label="Show more apps"');expect(html).toContain('aria-expanded="false"');expect(html).toContain("grid-rows-[0fr]");+ expect(html).not.toContain("Collapse");expect(html).toContain("/launch-icons/claude.svg");expect(html).toContain("/launch-icons/claude-code.svg");+ expect(html).not.toContain("<table");+ expect(html).not.toContain("<footer");+ expect(html).not.toContain("Command copied. Run it in your terminal.");expect(html).toContain("Run local models from your terminal");+ expect(html).not.toContain("Launch command");+ expect(html).not.toContain('aria-pressed="true"');+ expect(html).not.toContain("Continue");+ expect(html).not.toContain("Run Ollama");+ expect(html).not.toContain('viewBox="0 0 3400 3400"');});it("keeps connected Claude in Application without an idle status", () => {const html = renderToStaticMarkup(<ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}initialClaudeStatus={{+ supported: true,+ used: true,installed: true,- configured: true,connected: true,running: false,startFailed: false,+ portConflict: false,}}initialIntegrations={[{@@ -278,11 +332,14 @@ describe("Onboarding", () => {name: "Claude",description: "Use Ollama models in Claude Desktop",installed: true,+ action: "connect",},{id: "codex",name: "Codex",description: "OpenAI's open-source coding agent",+ installed: true,+ action: "copy",command: "ollama launch codex",},]}@@ -298,15 +355,21 @@ describe("Onboarding", () => {expect(html).toContain('aria-label="Disconnect Claude"');});- it("keeps failed configured Claude disconnectable", () => {+ it("shows initial Claude recovery guidance without error styling", () => {const html = renderToStaticMarkup(<ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}initialClaudeStatus={{+ supported: true,+ used: true,installed: true,configured: true,connected: false,running: false,startFailed: true,+ portConflict: false,+ error: "Cloud models are off. Select an installed model in Settings.",}}initialIntegrations={[{@@ -314,25 +377,82 @@ describe("Onboarding", () => {name: "Claude",description: "Use Ollama models in Claude Desktop",installed: true,+ action: "connect",},]}/>,);+ expect(html).toContain(+ "Cloud models are off. Select an installed model in Settings.",+ );+ expect(html).toContain('role="alert"');+ expect(html).not.toContain("text-red");expect(html).toContain('aria-checked="true"');expect(html).toContain('aria-label="Disconnect Claude"');- expect(html).toContain("Ollama couldn’t start the Claude connection.");+ });++ it("keeps Claude model management off the Connect Apps page", () => {+ const html = renderToStaticMarkup(+ <ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}+ initialClaudeStatus={{+ supported: true,+ used: true,+ installed: true,+ connected: true,+ running: true,+ startFailed: false,+ portConflict: false,+ modelSource: "endpoint",+ models: [+ {+ name: "glm-5.2:cloud",+ displayName: "GLM 5.2",+ description: "Long-horizon coding",+ selected: true,+ },+ {+ name: "qwen3.8:27b",+ displayName: "Qwen 3.8 27B",+ description: "Local coding",+ selected: false,+ },+ ],+ }}+ initialIntegrations={[+ {+ id: "claude-desktop",+ name: "Claude",+ description: "Use Ollama models in Claude Desktop",+ installed: true,+ action: "connect",+ },+ ]}+ />,+ );++ expect(html).not.toContain("Models in Claude");+ expect(html).not.toContain("GLM 5.2");+ expect(html).not.toContain("Qwen 3.8 27B");+ expect(html).not.toContain('type="checkbox"');+ expect(html).not.toContain("Restart Claude");+ expect(html).not.toContain("Built-in defaults");});it("keeps Claude available without a separate not-installed group", () => {const html = renderToStaticMarkup(<ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}initialIntegrations={[{id: "claude-desktop",name: "Claude",description: "Use Ollama models in Claude Desktop",installed: false,+ action: "connect",},]}/>,@@ -349,29 +469,35 @@ describe("Onboarding", () => {it("uses branded icons for the remaining launcher integrations", () => {const html = renderToStaticMarkup(<ConnectAppsScreen+ completionError={null}+ onRetryCompletion={vi.fn()}initialIntegrations={[{id: "cline",name: "Cline",description: "Autonomous coding agent",+ action: "copy",command: "ollama launch cline",},{id: "omp",name: "Oh My Pi",description: "AI coding agent",+ action: "copy",command: "ollama launch omp",},{id: "pool",name: "Poolside",description: "Poolside's coding agent",+ action: "copy",command: "ollama launch pool",},{id: "qwen",name: "Qwen Code",description: "Qwen's coding agent",+ action: "copy",command: "ollama launch qwen",},]}diff --git a/app/ui/app/src/components/Onboarding.tsx b/app/ui/app/src/components/Onboarding.tsxindex 9ca79bf9f..95cf2ca54 100644--- a/app/ui/app/src/components/Onboarding.tsx+++ b/app/ui/app/src/components/Onboarding.tsx@@ -8,6 +8,8 @@ import {} from "@/api";import { INTEGRATION_ICONS } from "@/lib/launchCommands";import {+ claudeDesktopRecoveryMessage,+ isClaudeConfigured,isClaudeConnectionComplete,scheduleClaudeInstallTimeout,} from "@/lib/claudeDesktop";@@ -414,32 +416,14 @@ export function ConnectAppsScreen({}, []);useEffect(() => {- if (initialIntegrations) return;-- let active = true;- getIntegrationStatuses()- .then((statuses) => {- if (active) setIntegrationStatuses(statuses);- })- .catch(() => {- if (active) setStatusError(true);- });-- return () => {- active = false;- };- }, [initialIntegrations]);-- useEffect(() => {- if (!copiedCommand && !claudeError) return;+ if (!copiedCommand) return;const timeout = window.setTimeout(() => {setCopiedCommand(null);- setClaudeError(null);}, 5000);return () => window.clearTimeout(timeout);- }, [claudeError, copiedCommand]);+ }, [copiedCommand]);const refreshClaudeStatus = useCallback(async () => {if (isWindows) return null;@@ -447,6 +431,7 @@ export function ConnectAppsScreen({try {const status = await window.getClaudeDesktopStatus();setClaudeStatus(status);+ setClaudeError(null);return status;} catch {setClaudeError("Ollama could not read the Claude connection status.");@@ -454,6 +439,38 @@ export function ConnectAppsScreen({}}, [isWindows]);+ useEffect(() => {+ let active = true;+ const integrations = initialIntegrations+ ? Promise.resolve(initialIntegrations)+ : getIntegrationStatuses();+ const claude = initialClaudeStatus+ ? Promise.resolve(initialClaudeStatus)+ : window.getClaudeDesktopStatus+ ? window.getClaudeDesktopStatus()+ : Promise.resolve(null);++ void Promise.allSettled([integrations, claude]).then(+ ([integrationResult, claudeResult]) => {+ if (!active) return;+ if (integrationResult.status === "fulfilled") {+ setIntegrationStatuses(integrationResult.value);+ } else {+ setStatusError(true);+ }+ if (claudeResult.status === "fulfilled") {+ setClaudeStatus(claudeResult.value);+ } else {+ setClaudeError("Ollama could not read the Claude connection status.");+ }+ },+ );++ return () => {+ active = false;+ };+ }, [initialClaudeStatus, initialIntegrations]);+const openConnectedClaude = useCallback(async (status: ClaudeDesktopStatus) => {if (!status.connected || status.running || !window.openClaudeDesktop) {@@ -505,7 +522,6 @@ export function ConnectAppsScreen({};useEffect(() => {- void refreshClaudeStatus();const handleFocus = () => void refreshClaudeStatus();window.addEventListener("focus", handleFocus);return () => window.removeEventListener("focus", handleFocus);@@ -643,7 +659,7 @@ export function ConnectAppsScreen({setClaudeError(null);const status = await refreshClaudeStatus();if (!status) return;- const enabling = !status.configured;+ const enabling = !isClaudeConfigured(status);if (enabling && !status.installed) {if (!window.installClaudeDesktop) {setClaudeError("Ollama could not open the Claude installer.");@@ -716,8 +732,10 @@ export function ConnectAppsScreen({integrationStatuses?.filter((item) => item.id !== "claude-desktop" && item.command,) ?? [];- const claudeConfigured = claudeStatus?.configured ?? false;const claudeConnected = claudeStatus?.connected ?? false;+ const claudeConfigured = claudeStatus+ ? isClaudeConfigured(claudeStatus)+ : false;const claudeInstalled =claudeStatus?.installed ?? claudeIntegration?.installed ?? false;const isConnectingClaude = claudePhase !== "idle";@@ -744,6 +762,10 @@ export function ConnectAppsScreen({: !claudeConfigured && !claudeInstalled? "Download & connect": null;+ const claudeGuidance = claudeDesktopRecoveryMessage(+ claudeStatus?.error,+ claudeError,+ );const launchIntegrationRow = (item: IntegrationStatus) => {const copied = copiedCommand === item.command;return (@@ -794,25 +816,23 @@ export function ConnectAppsScreen({{claudeIntegration.name}</p><p- role={claudeError ? "alert" : undefined}- className={`truncate text-xs leading-5 ${claudeError ? "text-red-600" : "text-neutral-500"}`}+ role={claudeGuidance ? "alert" : undefined}+ className="truncate text-xs leading-5 text-neutral-500">- {claudeError ??- (claudeConfigured && claudeStatus?.startFailed- ? "Ollama couldn’t start the Claude connection."- : claudeConnected- ? "Connected to Ollama"- : claudePhase === "installing"- ? "Ollama is downloading the Claude installer…"- : claudePhase === "waiting-for-install"- ? "Finish installing Claude. Ollama will connect it automatically."- : claudePhase === "connecting"- ? "Connecting Claude to Ollama…"- : claudePhase === "launching"- ? "Opening Claude…"- : claudePhase === "disconnecting"- ? "Restoring Claude’s usual connection…"- : claudeIntegration.description)}+ {claudeGuidance ??+ (claudeConnected+ ? "Connected to Ollama"+ : claudePhase === "installing"+ ? "Ollama is downloading the Claude installer…"+ : claudePhase === "waiting-for-install"+ ? "Finish installing Claude. Ollama will connect it automatically."+ : claudePhase === "connecting"+ ? "Connecting Claude to Ollama…"+ : claudePhase === "launching"+ ? "Opening Claude…"+ : claudePhase === "disconnecting"+ ? "Restoring Claude’s usual connection…"+ : claudeIntegration.description)}</p></div></div>@@ -988,13 +1008,14 @@ export function ConnectAppsScreen({id="claude-connected-title"className="font-rounded text-lg font-medium leading-6 text-neutral-950">- Ollama models are now available in Claude+ Easily access Ollama models in your Claude</h2><pid="claude-connected-description"className="mt-2 text-[13px] leading-5 text-neutral-500">- Choose an Ollama model from Claude's model selector.+ Ollama models now show up in Claude so you can pick the right+ model for the task.</p><div className="mt-5 flex justify-end"><buttondiff --git a/app/ui/app/src/components/Settings.tsx b/app/ui/app/src/components/Settings.tsxindex d97443d0e..d2ee133c2 100644--- a/app/ui/app/src/components/Settings.tsx+++ b/app/ui/app/src/components/Settings.tsx@@ -6,6 +6,7 @@ import { Field, Label, Description } from "@/components/ui/fieldset";import { Badge } from "@/components/ui/badge";import { Button } from "@/components/ui/button";import { Slider } from "@/components/ui/slider";+import { ClaudeDesktopModelsSettings } from "@/components/ClaudeDesktopModelsSettings";import {WifiIcon,FolderIcon,@@ -587,6 +588,8 @@ export default function Settings() {</div></div>+ <ClaudeDesktopModelsSettings />+{/* Agent Mode */}{window.OLLAMA_TOOLS && (<div className="overflow-hidden rounded-xl bg-white dark:bg-neutral-800">diff --git a/app/ui/app/src/lib/claudeDesktop.test.ts b/app/ui/app/src/lib/claudeDesktop.test.tsnew file mode 100644index 000000000..cc072532e--- /dev/null+++ b/app/ui/app/src/lib/claudeDesktop.test.ts@@ -0,0 +1,188 @@+import { describe, expect, it } from "vitest";+import {+ addClaudeModelSelection,+ claudeDesktopRecoveryMessage,+ claudeDesktopMaxModels,+ claudeDesktopMaxModelsMessage,+ claudeDesktopUsableSelection,+ defaultClaudeDesktopMaxModels,+ isClaudeConfigured,+} from "./claudeDesktop";++describe("isClaudeConfigured", () => {+ it("keeps a failed configured profile switchable off", () => {+ expect(+ isClaudeConfigured({+ supported: true,+ used: true,+ installed: true,+ configured: true,+ connected: false,+ running: false,+ startFailed: true,+ portConflict: true,+ }),+ ).toBe(true);+ });+});++describe("claudeDesktopMaxModels", () => {+ it("falls back to the five literal Claude slots without a status", () => {+ expect(claudeDesktopMaxModels(undefined)).toBe(5);+ expect(+ claudeDesktopMaxModels({+ supported: true,+ used: true,+ installed: true,+ connected: false,+ running: false,+ startFailed: false,+ portConflict: false,+ }),+ ).toBe(defaultClaudeDesktopMaxModels);+ });++ it("uses the server-provided limit when present", () => {+ expect(+ claudeDesktopMaxModels({+ supported: true,+ used: true,+ installed: true,+ connected: false,+ running: false,+ startFailed: false,+ portConflict: false,+ maxModels: 3,+ }),+ ).toBe(3);+ });+});++describe("claudeDesktopRecoveryMessage", () => {+ it("prefers current native guidance over stale action errors", () => {+ expect(+ claudeDesktopRecoveryMessage(+ "Cloud models are off. Select an installed model in Settings.",+ "Ollama could not open Claude.",+ ),+ ).toBe("Cloud models are off. Select an installed model in Settings.");+ });++ it("clears after native recovery when no action error remains", () => {+ expect(claudeDesktopRecoveryMessage(undefined, null)).toBeNull();+ });+});++describe("addClaudeModelSelection", () => {+ it("appends models below the limit", () => {+ expect(addClaudeModelSelection(["kimi-k3:cloud"], "qwen3:8b", 5)).toEqual({+ selection: ["kimi-k3:cloud", "qwen3:8b"],+ });+ });++ it("rejects a sixth selection with a clear message", () => {+ const selection = [+ "glm-5.2:cloud",+ "kimi-k3:cloud",+ "deepseek-v4-pro",+ "deepseek-v4-flash",+ "gemma4:26b:cloud",+ ];+ const result = addClaudeModelSelection(selection, "qwen3:8b", 5);+ expect(result.selection).toBe(selection);+ expect(result.error).toBe(+ "Claude supports up to 5 models. Deselect one to add another.",+ );+ });++ it("honors a smaller server-provided limit", () => {+ const result = addClaudeModelSelection(["qwen3:8b"], "llama3.2", 1);+ expect(result.selection).toEqual(["qwen3:8b"]);+ expect(result.error).toBe(claudeDesktopMaxModelsMessage(1));+ });++ it("is a no-op for an already selected model", () => {+ expect(addClaudeModelSelection(["qwen3:8b"], "qwen3:8b", 5)).toEqual({+ selection: ["qwen3:8b"],+ });+ });+});++describe("claudeDesktopUsableSelection", () => {+ it("replaces unavailable paid selections with an available free model", () => {+ expect(+ claudeDesktopUsableSelection([+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ selected: true,+ availability: "unavailable",+ reason: "upgrade_required",+ requiredPlan: "pro",+ },+ {+ name: "gemma4:31b-cloud",+ displayName: "gemma4:31b-cloud",+ selected: false,+ availability: "available",+ requiredPlan: "free",+ },+ ]),+ ).toEqual(["gemma4:31b-cloud"]);+ });++ it("preserves selected models that remain available", () => {+ expect(+ claudeDesktopUsableSelection([+ {+ name: "gemma4:31b-cloud",+ displayName: "gemma4:31b-cloud",+ selected: true,+ availability: "available",+ },+ {+ name: "qwen3:8b",+ displayName: "qwen3:8b",+ selected: false,+ availability: "available",+ },+ ]),+ ).toEqual(["gemma4:31b-cloud"]);+ });++ it("selects all available recommendations for a default catalog", () => {+ expect(+ claudeDesktopUsableSelection(+ [+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ selected: false,+ availability: "available",+ },+ {+ name: "kimi-k3:cloud",+ displayName: "kimi-k3:cloud",+ selected: false,+ availability: "available",+ },+ ],+ true,+ 5,+ ),+ ).toEqual(["glm-5.2:cloud", "kimi-k3:cloud"]);+ });++ it("returns no selection when no model is available", () => {+ expect(+ claudeDesktopUsableSelection([+ {+ name: "glm-5.2:cloud",+ displayName: "glm-5.2:cloud",+ selected: true,+ availability: "unavailable",+ },+ ]),+ ).toEqual([]);+ });+});diff --git a/app/ui/app/src/lib/claudeDesktop.ts b/app/ui/app/src/lib/claudeDesktop.tsindex 46743b3e9..13f1f88e4 100644--- a/app/ui/app/src/lib/claudeDesktop.ts+++ b/app/ui/app/src/lib/claudeDesktop.ts@@ -1,4 +1,7 @@-import type { ClaudeDesktopStatus } from "@/types/webview";+import type {+ ClaudeDesktopModelStatus,+ ClaudeDesktopStatus,+} from "@/types/webview";export const CLAUDE_INSTALL_TIMEOUT_MS = 120_000;@@ -6,9 +9,74 @@ export function isClaudeConnectionComplete(enabled: boolean,status: ClaudeDesktopStatus,) {- return enabled ? status.connected && !status.startFailed : !status.configured;+ const configured = isClaudeConfigured(status);+ return enabled+ ? configured && status.connected && !status.startFailed+ : !configured;+}++export function isClaudeConfigured(status: ClaudeDesktopStatus): boolean {+ return status.configured ?? status.connected;+}++export function claudeDesktopRecoveryMessage(+ statusError?: string,+ actionError?: string | null,+): string | null {+ return statusError || actionError || null;}export function scheduleClaudeInstallTimeout(onTimeout: () => void) {return window.setTimeout(onTimeout, CLAUDE_INSTALL_TIMEOUT_MS);}++// Claude Desktop has a bounded model list. The app supplies the limit when it+// knows it; retain the existing five-model behavior for older app versions.+export const defaultClaudeDesktopMaxModels = 5;++export function claudeDesktopMaxModels(+ status?: ClaudeDesktopStatus | null,+): number {+ return status?.maxModels && status.maxModels > 0+ ? status.maxModels+ : defaultClaudeDesktopMaxModels;+}++export function claudeDesktopMaxModelsMessage(maxModels: number): string {+ return `Claude supports up to ${maxModels} models. Deselect one to add another.`;+}++// Unavailable models remain visible for account guidance, but cannot remain+// selected. Choose one available model when filtering would empty the list.+export function claudeDesktopUsableSelection(+ models: ClaudeDesktopModelStatus[],+ selectAllAvailable = false,+ maxModels = defaultClaudeDesktopMaxModels,+): string[] {+ const available = models.filter(+ (model) =>+ model.availability === undefined || model.availability === "available",+ );+ if (selectAllAvailable) {+ return available.slice(0, maxModels).map((model) => model.name);+ }+ const selected = available+ .filter((model) => model.selected)+ .map((model) => model.name);+ if (selected.length > 0) return selected;+ return available.length > 0 ? [available[0].name] : [];+}++// addClaudeModelSelection returns the selection with name appended, or an+// unchanged selection plus an error when the Claude model limit is reached.+export function addClaudeModelSelection(+ selection: string[],+ name: string,+ maxModels: number,+): { selection: string[]; error?: string } {+ if (selection.includes(name)) return { selection };+ if (selection.length >= maxModels) {+ return { selection, error: claudeDesktopMaxModelsMessage(maxModels) };+ }+ return { selection: [...selection, name] };+}diff --git a/app/ui/app/src/types/webview.d.ts b/app/ui/app/src/types/webview.d.tsindex ae0920507..ae8e9c043 100644--- a/app/ui/app/src/types/webview.d.ts+++ b/app/ui/app/src/types/webview.d.ts@@ -13,11 +13,35 @@ interface MenuItem {}interface ClaudeDesktopStatus {+ supported: boolean;+ used: boolean;installed: boolean;- configured: boolean;+ configured?: boolean;connected: boolean;running: boolean;startFailed: boolean;+ portConflict: boolean;+ gatewayPort?: number;+ error?: string;+ modelSource?: "user" | "endpoint" | "fallback";+ maxModels?: number;+ models?: ClaudeDesktopModelStatus[];+}++interface ClaudeDesktopModelStatus {+ name: string;+ displayName: string;+ description?: string;+ cloud?: boolean;+ selected: boolean;+ availability?: "unknown" | "available" | "unavailable";+ reason?:+ | "cloud_off"+ | "sign_in_required"+ | "upgrade_required"+ | "verification_unavailable"+ | "model_not_installed";+ requiredPlan?: string;}interface ClaudeDesktopActionResult {@@ -49,6 +73,9 @@ declare global {installClaudeDesktop?: () => Promise<ClaudeDesktopInstallResult>;getShowAppsInMenu?: () => Promise<boolean>;setShowAppsInMenu?: (visible: boolean) => Promise<void>;+ restartClaudeDesktop?: (+ models: string[],+ ) => Promise<ClaudeDesktopActionResult>;setOnboardingWindow?: (enabled: boolean) => void;menu: (items: MenuItem[]) => Promise<string | null>;OLLAMA_TOOLS?: boolean;@@ -76,6 +103,7 @@ declare global {export type {ClaudeDesktopActionResult,ClaudeDesktopInstallResult,+ ClaudeDesktopModelStatus,ClaudeDesktopStatus,ContextMenuItem,ContextMenuResult,diff --git a/app/ui/ui.go b/app/ui/ui.goindex 8ed2561b6..4b4a031d7 100644--- a/app/ui/ui.go+++ b/app/ui/ui.go@@ -111,9 +111,10 @@ type Server struct {Dev bool// Updater for checking and downloading updates- Updater *updater.Updater- UpdateAvailableFunc func()- ClaudeDesktopInstalled func() bool+ Updater *updater.Updater+ UpdateAvailableFunc func()+ IntegrationInstalled func(string) bool+ ListCloudModels func(context.Context) (*api.ListResponse, error)}func (s *Server) log() *slog.Logger {@@ -294,6 +295,7 @@ func (s *Server) Handler() http.Handler {mux.Handle("POST /api/v1/settings", handle(s.settings))mux.Handle("GET /api/v1/cloud", handle(s.getCloudSetting))mux.Handle("POST /api/v1/cloud", handle(s.cloudSetting))+ mux.Handle("GET /api/v1/models/cloud", handle(s.getCloudModels))mux.Handle("GET /api/v1/integrations", handle(s.getIntegrationStatuses))// Ollama proxy endpoints@@ -317,62 +319,59 @@ func (s *Server) Handler() http.Handler {return mux}-func supportsClaudeDesktopIntegration(goos string) bool {- return goos == "darwin"-}-func (s *Server) getIntegrationStatuses(w http.ResponseWriter, _ *http.Request) error {+ isInstalled := s.IntegrationInstalled+ if isInstalled == nil {+ isInstalled = launch.IsIntegrationInstalled+ }+type integrationStatus struct {ID string `json:"id"`Name string `json:"name"`Description string `json:"description"`Installed *bool `json:"installed,omitempty"`+ Action string `json:"action"`Command string `json:"command,omitempty"`}infos := launch.ListIntegrationInfos()statuses := make([]integrationStatus, 0, len(infos)+2)- if supportsClaudeDesktopIntegration(runtime.GOOS) {- var claudeDesktopInstalled bool- if s.ClaudeDesktopInstalled != nil {- claudeDesktopInstalled = s.ClaudeDesktopInstalled()- } else {- claudeDesktopInstalled = launch.IsIntegrationInstalled("claude-desktop")- }- statuses = append(statuses, integrationStatus{- ID: "claude-desktop",- Name: "Claude",- Description: "Use Ollama models in Claude Desktop",- Installed: &claudeDesktopInstalled,- })- }+ claudeDesktopInstalled := isInstalled("claude-desktop")+ statuses = append(statuses, integrationStatus{+ ID: "claude-desktop",+ Name: "Claude",+ Description: "Use Ollama models in Claude Desktop",+ Installed: &claudeDesktopInstalled,+ Action: "connect",+ })byName := make(map[string]launch.IntegrationInfo, len(infos))for _, info := range infos {byName[info.Name] = info}- // Apps prioritizes the primary terminal agents; unlisted entries retain launcher order.- preferredOrder := []string{"claude", "codex", "openclaw", "opencode", "droid", "pi", "cline"}- seen := make(map[string]bool, len(preferredOrder))+ seen := map[string]bool{"chatgpt": true}+ launcherMenuOrder := []string{"claude", "codex", "openclaw", "opencode", "droid", "pi", "cline"}orderedInfos := make([]launch.IntegrationInfo, 0, len(infos))- for _, name := range preferredOrder {+ for _, name := range launcherMenuOrder {if info, ok := byName[name]; ok {orderedInfos = append(orderedInfos, info)seen[name] = true}}for _, info := range infos {- if info.Name == "chatgpt" || seen[info.Name] {- continue+ if !seen[info.Name] {+ orderedInfos = append(orderedInfos, info)}- orderedInfos = append(orderedInfos, info)}for _, info := range orderedInfos {+ installed := isInstalled(info.Name)statuses = append(statuses, integrationStatus{ID: info.Name,Name: info.DisplayName,Description: info.Description,+ Installed: &installed,+ Action: "copy",Command: "ollama launch " + info.Name,})}@@ -381,6 +380,7 @@ func (s *Server) getIntegrationStatuses(w http.ResponseWriter, _ *http.Request)ID: "terminal",Name: "Terminal",Description: "Run local models from your terminal",+ Action: "copy",Command: "ollama",})@@ -1540,6 +1540,7 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) error {var request struct {store.SettingsOnboardingVersion *int+ ClaudeDesktopUsed *bool}if err := json.NewDecoder(r.Body).Decode(&request); err != nil {return fmt.Errorf("invalid request body: %w", err)@@ -1551,6 +1552,11 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) error {} else {settings.OnboardingVersion = *request.OnboardingVersion}+ if request.ClaudeDesktopUsed == nil {+ settings.ClaudeDesktopUsed = old.ClaudeDesktopUsed+ } else {+ settings.ClaudeDesktopUsed = *request.ClaudeDesktopUsed+ }if err := s.Store.SetSettings(settings); err != nil {return fmt.Errorf("failed to save settings: %w", err)@@ -1620,6 +1626,58 @@ func (s *Server) writeCloudStatus(w http.ResponseWriter) error {})}+func (s *Server) getCloudModels(w http.ResponseWriter, r *http.Request) error {+ w.Header().Set("Content-Type", "application/json")+ disabled, _, err := s.Store.CloudStatus()+ if err != nil {+ return fmt.Errorf("failed to load cloud status: %w", err)+ }+ if disabled {+ return json.NewEncoder(w).Encode(api.ListResponse{Models: []api.ListModelResponse{}})+ }++ list := s.ListCloudModels+ if list == nil {+ list = s.listCloudModels+ }+ ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)+ defer cancel()+ models, err := list(ctx)+ if err != nil {+ var authErr api.AuthorizationError+ if errors.As(err, &authErr) && (authErr.StatusCode == http.StatusUnauthorized || authErr.StatusCode == http.StatusForbidden) {+ return json.NewEncoder(w).Encode(api.ListResponse{Models: []api.ListModelResponse{}})+ }+ return fmt.Errorf("failed to list cloud models: %w", err)+ }+ if models == nil {+ models = &api.ListResponse{Models: []api.ListModelResponse{}}+ }++ return json.NewEncoder(w).Encode(models)+}++func (s *Server) listCloudModels(ctx context.Context) (*api.ListResponse, error) {+ resp, err := s.doSelfSigned(ctx, http.MethodGet, "/api/tags")+ if err != nil {+ return nil, err+ }+ defer resp.Body.Close()++ if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {+ return nil, api.AuthorizationError{StatusCode: resp.StatusCode}+ }+ if resp.StatusCode != http.StatusOK {+ return nil, fmt.Errorf("ollama.com/api/tags returned %s", resp.Status)+ }++ var models api.ListResponse+ if err := json.NewDecoder(resp.Body).Decode(&models); err != nil {+ return nil, fmt.Errorf("failed to parse cloud models: %w", err)+ }+ return &models, nil+}+func (s *Server) getInferenceCompute(w http.ResponseWriter, r *http.Request) error {ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)defer cancel()diff --git a/app/ui/ui_test.go b/app/ui/ui_test.goindex 4f2709d79..64d7caf30 100644--- a/app/ui/ui_test.go+++ b/app/ui/ui_test.go@@ -122,8 +122,8 @@ func TestHandlePostApiSettings(t *testing.T) {func TestGetIntegrationStatuses(t *testing.T) {server := &Server{- ClaudeDesktopInstalled: func() bool {- return true+ IntegrationInstalled: func(name string) bool {+ return name == "claude-desktop" || name == "codex"},}req := httptest.NewRequest(http.MethodGet, "/api/v1/integrations", nil)@@ -136,6 +136,7 @@ func TestGetIntegrationStatuses(t *testing.T) {var got []struct {ID string `json:"id"`Installed *bool `json:"installed"`+ Action string `json:"action"`Command string `json:"command"`}if err := json.NewDecoder(rr.Body).Decode(&got); err != nil {@@ -145,13 +146,10 @@ func TestGetIntegrationStatuses(t *testing.T) {if len(got) < 5 {t.Fatalf("got %d integrations, want the full registry", len(got))}- wantPrefix := []string{"claude", "codex", "openclaw", "opencode", "droid", "pi", "cline"}- if runtime.GOOS == "darwin" {- if got[0].ID != "claude-desktop" || got[0].Installed == nil || !*got[0].Installed || got[0].Command != "" {- t.Fatalf("first integration = %+v, want command-free Claude Desktop connect", got[0])- }- wantPrefix = append([]string{"claude-desktop"}, wantPrefix...)+ if got[0].ID != "claude-desktop" || got[0].Action != "connect" || got[0].Command != "" {+ t.Fatalf("first integration = %+v, want command-free Claude Desktop connect", got[0])}+ wantPrefix := []string{"claude-desktop", "claude", "codex", "openclaw", "opencode", "droid", "pi", "cline"}for i, want := range wantPrefix {if got[i].ID != want {t.Fatalf("integration %d = %q, want launcher menu order entry %q", i, got[i].ID, want)@@ -159,35 +157,34 @@ func TestGetIntegrationStatuses(t *testing.T) {}byID := make(map[string]struct {Installed *bool+ Action stringCommand string}, len(got))for _, item := range got {byID[item.ID] = struct {Installed *bool+ Action stringCommand string- }{item.Installed, item.Command}+ }{item.Installed, item.Action, item.Command}}- if runtime.GOOS != "darwin" {- if _, ok := byID["claude-desktop"]; ok {- t.Fatal("Claude Desktop should not be exposed on Windows")- }- }- for name, item := range byID {- if name != "claude-desktop" && item.Installed != nil {- t.Errorf("%s should not include unused install status", name)+ for name, want := range map[string]bool{+ "claude-desktop": true,+ "opencode": false,+ "codex": true,+ } {+ item, ok := byID[name]+ if !ok || item.Installed == nil || *item.Installed != want {+ t.Errorf("%s installed = %v, want %v", name, item.Installed, want)}}if item, ok := byID["claude"]; !ok || item.Command != "ollama launch claude" {- t.Fatal("Claude Code should include its launch command")+ t.Fatal("Claude Code should follow Claude Desktop with its launch command")}if _, ok := byID["chatgpt"]; ok {t.Fatal("ChatGPT should be excluded from onboarding integrations")}- wantCount := len(launch.ListIntegrationInfos()) // Terminal replaces omitted ChatGPT.- if runtime.GOOS == "darwin" {- wantCount++ // Claude Desktop is also available on macOS.- }+ wantCount := len(launch.ListIntegrationInfos()) + 1 // Claude Desktop and Terminal replace omitted ChatGPT.if len(got) != wantCount {t.Fatalf("got %d integrations, want %d launcher entries", len(got), wantCount)}@@ -197,15 +194,6 @@ func TestGetIntegrationStatuses(t *testing.T) {}}-func TestSupportsClaudeDesktopIntegration(t *testing.T) {- if !supportsClaudeDesktopIntegration("darwin") {- t.Fatal("Claude Desktop should be available on macOS")- }- if supportsClaudeDesktopIntegration("windows") {- t.Fatal("Claude Desktop should be hidden on Windows")- }-}-func TestHandlePostApiCloudSetting(t *testing.T) {tmpHome := t.TempDir()t.Setenv("HOME", tmpHome)@@ -614,6 +602,63 @@ func TestUserAgentTransport(t *testing.T) {t.Logf("User-Agent transport successfully set: %s", receivedUA)}+func TestGetCloudModels(t *testing.T) {+ t.Run("does not call ollama.com when cloud is disabled", func(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ t.Setenv("OLLAMA_NO_CLOUD", "1")+ testStore := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}+ defer testStore.Close()++ server := &Server{+ Store: testStore,+ ListCloudModels: func(context.Context) (*api.ListResponse, error) {+ t.Fatal("cloud model list called while cloud was disabled")+ return nil, nil+ },+ }+ req := httptest.NewRequest(http.MethodGet, "/api/v1/models/cloud", nil)+ rr := httptest.NewRecorder()+ if err := server.getCloudModels(rr, req); err != nil {+ t.Fatal(err)+ }++ var got api.ListResponse+ if err := json.NewDecoder(rr.Body).Decode(&got); err != nil {+ t.Fatal(err)+ }+ if len(got.Models) != 0 {+ t.Fatalf("models = %+v, want none", got.Models)+ }+ })++ t.Run("returns no cloud models when account is unauthorized", func(t *testing.T) {+ t.Setenv("HOME", t.TempDir())+ t.Setenv("OLLAMA_NO_CLOUD", "")+ testStore := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}+ defer testStore.Close()++ server := &Server{+ Store: testStore,+ ListCloudModels: func(context.Context) (*api.ListResponse, error) {+ return nil, api.AuthorizationError{StatusCode: http.StatusUnauthorized}+ },+ }+ req := httptest.NewRequest(http.MethodGet, "/api/v1/models/cloud", nil)+ rr := httptest.NewRecorder()+ if err := server.getCloudModels(rr, req); err != nil {+ t.Fatal(err)+ }++ var got api.ListResponse+ if err := json.NewDecoder(rr.Body).Decode(&got); err != nil {+ t.Fatal(err)+ }+ if len(got.Models) != 0 {+ t.Fatalf("models = %+v, want none", got.Models)+ }+ })+}+func TestInferenceClientUsesUserAgent(t *testing.T) {var gotUserAgent atomic.Valuets := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {@@ -854,6 +899,51 @@ func TestSettingsPreservesOnboardingVersionWhenOmitted(t *testing.T) {}}+func TestSettingsPreservesClaudeDesktopUsedWhenOmitted(t *testing.T) {+ testStore := &store.Store{+ DBPath: filepath.Join(t.TempDir(), "db.sqlite"),+ }+ defer testStore.Close()++ settings, err := testStore.Settings()+ if err != nil {+ t.Fatal(err)+ }+ settings.ClaudeDesktopUsed = true+ if err := testStore.SetSettings(settings); err != nil {+ t.Fatal(err)+ }++ payload, err := json.Marshal(settings)+ if err != nil {+ t.Fatal(err)+ }+ var fields map[string]any+ if err := json.Unmarshal(payload, &fields); err != nil {+ t.Fatal(err)+ }+ delete(fields, "ClaudeDesktopUsed")+ payload, err = json.Marshal(fields)+ if err != nil {+ t.Fatal(err)+ }++ server := &Server{Store: testStore, Restart: func() {}}+ req := httptest.NewRequest("POST", "/api/v1/settings", bytes.NewReader(payload))+ rr := httptest.NewRecorder()+ if err := server.settings(rr, req); err != nil {+ t.Fatalf("settings() error = %v", err)+ }++ saved, err := testStore.Settings()+ if err != nil {+ t.Fatal(err)+ }+ if !saved.ClaudeDesktopUsed {+ t.Fatal("expected ClaudeDesktopUsed to be preserved")+ }+}+func TestSettingsToggleAutoUpdateOn_WithPendingUpdate_ShowsNotification(t *testing.T) {testStore := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite"),diff --git a/cmd/launch/claude_desktop.go b/cmd/launch/claude_desktop.goindex d1618ac54..929ef2060 100644--- a/cmd/launch/claude_desktop.go+++ b/cmd/launch/claude_desktop.go@@ -63,6 +63,9 @@ func (c *ClaudeDesktop) AutodiscoveredModel() string {return claudeDesktopModelLabel}+// ConfigureAutodiscovery points Claude Desktop at Ollama's local gateway+// without pinning a model list, so Claude discovers the selected catalog and+// exact Ollama route names the gateway advertises.func (c *ClaudeDesktop) ConfigureAutodiscovery() error {if err := claudeDesktopSupported(); err != nil {return err@@ -138,6 +141,25 @@ func (c *ClaudeDesktop) SetInstalledFromDesktop(installed, restart bool) error {return restartClaudeDesktop(applyProfile)}+// RestartWithProfileChange stops Claude before applying a profile-dependent+// change, then reopens it after the change is complete.+func (c *ClaudeDesktop) RestartWithProfileChange(change func() error) error {+ if err := claudeDesktopSupported(); err != nil {+ return err+ }+ running, err := claudeDesktopIsRunning(context.Background())+ if err != nil {+ return fmt.Errorf("check whether Claude Desktop is running: %w", err)+ }+ if !running {+ if err := change(); err != nil {+ return err+ }+ return claudeDesktopOpenApp()+ }+ return restartClaudeDesktop(change)+}+// RestoreForShutdown restores Claude's usual profile without reopening the app.func (c *ClaudeDesktop) RestoreForShutdown(ctx context.Context) error {if err := claudeDesktopSupported(); err != nil {@@ -171,6 +193,27 @@ func (c *ClaudeDesktop) Onboard() error {return config.MarkIntegrationOnboarded(claudeDesktopIntegrationName)}+// ClaudeDesktopModels returns the user's explicitly saved Claude Desktop+// model subset. A nil result means the recommendation source should decide.+func ClaudeDesktopModels() []string {+ return config.IntegrationModels(claudeDesktopIntegrationName)+}++// SaveClaudeDesktopModels persists the user's explicit Claude Desktop model+// subset in the shared launcher configuration.+func SaveClaudeDesktopModels(models []string) error {+ if len(models) == 0 {+ return errors.New("select at least one Claude Desktop model")+ }+ return config.SaveIntegration(claudeDesktopIntegrationName, models)+}++// RestoreClaudeDesktopModels restores a previously captured selection. A nil+// selection restores the implicit recommendation defaults.+func RestoreClaudeDesktopModels(models []string) error {+ return config.SaveIntegration(claudeDesktopIntegrationName, models)+}+func (c *ClaudeDesktop) RequiresInteractiveOnboarding() bool {return false}@@ -574,6 +617,7 @@ func writeClaudeDesktopGatewayProfile(path, baseURL, apiKey string, forceChoosercfg["inferenceGatewayBaseUrl"] = baseURLcfg["inferenceGatewayApiKey"] = apiKeycfg["inferenceGatewayAuthScheme"] = "bearer"+ cfg["deploymentDisplayName"] = claudeDesktopProfileNamecfg["chatTabEnabled"] = truedelete(cfg, "inferenceModels")cfg["disableDeploymentModeChooser"] = forceChooser@@ -634,6 +678,7 @@ func restoreClaudeDesktopOllamaProfile(path string) error {delete(cfg, "inferenceProvider")delete(cfg, "inferenceGatewayBaseUrl")delete(cfg, "inferenceGatewayAuthScheme")+ delete(cfg, "deploymentDisplayName")delete(cfg, "inferenceModels")delete(cfg, "coworkEgressAllowedHosts")delete(cfg, "autoModeEnabled")@@ -704,6 +749,9 @@ func claudeDesktopThirdPartyProfileConfigured(target claudeDesktopThirdPartyPathif s, _ := cfg["inferenceGatewayApiKey"].(string); strings.TrimSpace(s) == "" {return false}+ if s, _ := cfg["deploymentDisplayName"].(string); s != claudeDesktopProfileName {+ return false+ }egressHosts := claudeDesktopAnySlice(cfg["coworkEgressAllowedHosts"])if len(egressHosts) != len(claudeDesktopEgressHosts) {return falsediff --git a/cmd/launch/claude_desktop_test.go b/cmd/launch/claude_desktop_test.goindex 6b2481821..b140a1139 100644--- a/cmd/launch/claude_desktop_test.go+++ b/cmd/launch/claude_desktop_test.go@@ -9,6 +9,7 @@ import ("net/http/httptest""os""path/filepath"+ "slices""strings""testing""time"@@ -263,6 +264,9 @@ func TestClaudeDesktopConfigureWritesOllamaCloudProfile(t *testing.T) {if profile["inferenceGatewayAuthScheme"] != "bearer" {t.Fatalf("auth scheme = %v, want bearer", profile["inferenceGatewayAuthScheme"])}+ if profile["deploymentDisplayName"] != "Ollama" {+ t.Fatalf("deployment display name = %v, want Ollama", profile["deploymentDisplayName"])+ }if profile["disableDeploymentModeChooser"] != true {t.Fatalf("disableDeploymentModeChooser = %v, want true", profile["disableDeploymentModeChooser"])}@@ -642,6 +646,34 @@ func TestClaudeDesktopAutodiscoveryConfiguredRequiresAPIKey(t *testing.T) {}}+func TestClaudeDesktopAutodiscoveryConfiguredRequiresDisplayName(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withClaudeDesktopPlatform(t, "darwin")++ c := &ClaudeDesktop{}+ if err := c.ConfigureAutodiscovery(); err != nil {+ t.Fatalf("Configure returned error: %v", err)+ }++ paths, err := claudeDesktopConfigPaths()+ if err != nil {+ t.Fatal(err)+ }+ profile := claudeDesktopReadJSON(t, paths.profile)+ delete(profile, "deploymentDisplayName")+ if err := writeClaudeDesktopJSON(paths.profile, profile); err != nil {+ t.Fatal(err)+ }++ if c.AutodiscoveryConfigured() {+ t.Fatal("expected missing deployment display name to force Claude Desktop reconfiguration")+ }+ if !c.UsesOllamaGateway() {+ t.Fatal("expected missing deployment display name to leave Ollama routing active")+ }+}+func TestClaudeDesktopAutodiscoveryConfiguredRequiresTelemetryDisabled(t *testing.T) {tmpDir := t.TempDir()setTestHome(t, tmpDir)@@ -799,7 +831,7 @@ func TestClaudeDesktopRestoreSwitchesBackToFirstPartyMode(t *testing.T) {if err := os.WriteFile(paths.meta, []byte(`{"appliedId":"`+claudeDesktopProfileID+`","entries":[{"id":"`+claudeDesktopProfileID+`","name":"Ollama"}]}`), 0o644); err != nil {t.Fatal(err)}- if err := os.WriteFile(paths.profile, []byte(`{"autoModeEnabled":true,"coworkEgressAllowedHosts":["github.com"],"disableDeploymentModeChooser":true,"disableEssentialTelemetry":true,"disableNonessentialTelemetry":true,"inferenceGatewayApiKey":"keep","inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://ollama.com","inferenceGatewayAuthScheme":"bearer","inferenceModels":["legacy"]}`), 0o644); err != nil {+ if err := os.WriteFile(paths.profile, []byte(`{"autoModeEnabled":true,"coworkEgressAllowedHosts":["github.com"],"deploymentDisplayName":"Ollama","disableDeploymentModeChooser":true,"disableEssentialTelemetry":true,"disableNonessentialTelemetry":true,"inferenceGatewayApiKey":"keep","inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://ollama.com","inferenceGatewayAuthScheme":"bearer","inferenceModels":["legacy"]}`), 0o644); err != nil {t.Fatal(err)}@@ -822,7 +854,7 @@ func TestClaudeDesktopRestoreSwitchesBackToFirstPartyMode(t *testing.T) {if profile["inferenceGatewayApiKey"] != "keep" {t.Fatal("restore should leave existing Ollama profile credentials in place")}- for _, key := range []string{"inferenceProvider", "inferenceGatewayBaseUrl", "inferenceGatewayAuthScheme", "inferenceModels", "coworkEgressAllowedHosts", "autoModeEnabled", "disableEssentialTelemetry", "disableNonessentialTelemetry"} {+ for _, key := range []string{"inferenceProvider", "inferenceGatewayBaseUrl", "inferenceGatewayAuthScheme", "deploymentDisplayName", "inferenceModels", "coworkEgressAllowedHosts", "autoModeEnabled", "disableEssentialTelemetry", "disableNonessentialTelemetry"} {if _, ok := profile[key]; ok {t.Fatalf("restore should clear stale %s from the Ollama profile: %v", key, profile)}@@ -943,6 +975,138 @@ func TestClaudeDesktopSetInstalledFromDesktopRequiresRestartConfirmation(t *test}}+func TestClaudeDesktopModelsPersistInLauncherConfig(t *testing.T) {+ setTestHome(t, t.TempDir())+ want := []string{"qwen3.8:27b", "glm-5.2:cloud"}+ if err := SaveClaudeDesktopModels(want); err != nil {+ t.Fatal(err)+ }+ if got := ClaudeDesktopModels(); !slices.Equal(got, want) {+ t.Fatalf("ClaudeDesktopModels() = %v, want %v", got, want)+ }+ if err := SaveClaudeDesktopModels(nil); err == nil {+ t.Fatal("SaveClaudeDesktopModels(nil) succeeded")+ }+}++func TestClaudeDesktopConfigureOmitsInferenceModelsWithoutMappedIDs(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withClaudeDesktopPlatform(t, "darwin")++ paths, err := claudeDesktopConfigPaths()+ if err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(paths.desktopConfig), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(paths.meta), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(paths.desktopConfig, []byte(`{}`), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(paths.meta, []byte(`{"entries":[]}`), 0o644); err != nil {+ t.Fatal(err)+ }++ // Persisted selections keep exact Ollama routes, but the generic configure+ // path must not write them as inferenceModels: Claude Desktop autodiscovers+ // the Claude-facing IDs the gateway advertises instead.+ persisted := []string{"glm-5.2:cloud", "deepseek-v4-flash:cloud", "gemma4:26b:cloud", "qwen3:8b"}+ if err := SaveClaudeDesktopModels(persisted); err != nil {+ t.Fatal(err)+ }+ if err := (&ClaudeDesktop{}).ConfigureAutodiscovery(); err != nil {+ t.Fatal(err)+ }++ profile := claudeDesktopReadJSON(t, paths.profile)+ if models, ok := profile["inferenceModels"]; ok {+ t.Fatalf("inferenceModels = %v, want omitted so Claude discovers gateway models", models)+ }+ if got := ClaudeDesktopModels(); !slices.Equal(got, persisted) {+ t.Fatalf("persisted models = %v, want Ollama routes %v", got, persisted)+ }+}++func TestClaudeDesktopSetInstalledFromDesktopUsesGatewayDiscovery(t *testing.T) {+ setTestHome(t, t.TempDir())+ withClaudeDesktopPlatform(t, "darwin")+ openCalls := 0+ withClaudeDesktopProcessHooks(t,+ func() bool { return false },+ func() error { t.Fatal("stopped Claude should not be quit"); return nil },+ func() error { openCalls++; return nil },+ )++ paths, err := claudeDesktopConfigPaths()+ if err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(paths.profile, []byte(`{"customSetting":{"nested":true},"inferenceModels":["kimi-k3:cloud"]}`), 0o644); err != nil {+ t.Fatal(err)+ }++ // Settings persist exact Ollama routes while Claude discovers that selected+ // catalog from the gateway instead of a stale profile list.+ persisted := []string{"kimi-k3:cloud", "gemma4:26b:cloud"}+ if err := SaveClaudeDesktopModels(persisted); err != nil {+ t.Fatal(err)+ }+ if err := (&ClaudeDesktop{}).SetInstalledFromDesktop(true, false); err != nil {+ t.Fatalf("SetInstalledFromDesktop returned error: %v", err)+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }++ profile := claudeDesktopReadJSON(t, paths.profile)+ if models, ok := profile["inferenceModels"]; ok {+ t.Fatalf("inferenceModels = %v, want gateway discovery", models)+ }+ custom, _ := profile["customSetting"].(map[string]any)+ if custom["nested"] != true {+ t.Fatalf("unknown profile fields were not preserved: %v", profile)+ }+ if got := ClaudeDesktopModels(); !slices.Equal(got, persisted) {+ t.Fatalf("persisted models = %v, want Ollama routes %v", got, persisted)+ }+}++func TestClaudeDesktopSetInstalledFromDesktopOmitsInferenceModelsWithoutMappedIDs(t *testing.T) {+ setTestHome(t, t.TempDir())+ withClaudeDesktopPlatform(t, "darwin")+ withClaudeDesktopProcessHooks(t,+ func() bool { return false },+ func() error { t.Fatal("stopped Claude should not be quit"); return nil },+ func() error { return nil },+ )++ paths, err := claudeDesktopConfigPaths()+ if err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(paths.profile), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(paths.profile, []byte(`{"inferenceModels":["kimi-k3:cloud"]}`), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&ClaudeDesktop{}).SetInstalledFromDesktop(true, false); err != nil {+ t.Fatalf("SetInstalledFromDesktop returned error: %v", err)+ }+ profile := claudeDesktopReadJSON(t, paths.profile)+ if models, ok := profile["inferenceModels"]; ok {+ t.Fatalf("inferenceModels = %v, want omitted without mapped IDs", models)+ }+}+func TestClaudeDesktopSetInstalledFromDesktopOpensStoppedAppWhenEnabled(t *testing.T) {setTestHome(t, t.TempDir())withClaudeDesktopPlatform(t, "darwin")diff --git a/internal/proxy/claude_desktop.go b/internal/proxy/claude_desktop.goindex dc319e004..0a403bab4 100644--- a/internal/proxy/claude_desktop.go+++ b/internal/proxy/claude_desktop.go@@ -18,7 +18,6 @@ import ("time""github.com/ollama/ollama/anthropic"- "github.com/ollama/ollama/internal/modelref")const (@@ -35,61 +34,6 @@ const (unsupportedImageNotice = "[Image omitted by Ollama because the selected model does not support image recognition.]")-// claudeModels are Claude-compatible IDs for Ollama models-var claudeModels = []gatewayModel{- {- ID: "claude-fable-5",- Type: "model",- DisplayName: "GLM 5.2",- CreatedAt: "2026-06-09T00:00:00Z",- MaxTokens: 128_000,- AnthropicFamilyTier: "fable",- IsFamilyDefault: true,- OllamaModel: "glm-5.2:cloud",- },- {- ID: "claude-opus-5",- Type: "model",- DisplayName: "Kimi K3",- CreatedAt: "2026-07-24T00:00:00Z",- MaxTokens: 262_144,- AnthropicFamilyTier: "opus",- IsFamilyDefault: true,- OllamaModel: "kimi-k3:cloud",- SupportsVision: true,- },- {- ID: "claude-sonnet-5",- Type: "model",- DisplayName: "DeepSeek V4 Pro",- CreatedAt: "2026-06-30T00:00:00Z",- MaxTokens: 128_000,- AnthropicFamilyTier: "sonnet",- IsFamilyDefault: true,- OllamaModel: "deepseek-v4-pro:cloud",- },- {- ID: "claude-haiku-4-5-20251001",- Type: "model",- DisplayName: "DeepSeek V4 Flash",- CreatedAt: "2025-10-01T00:00:00Z",- MaxTokens: 64_000,- AnthropicFamilyTier: "haiku",- IsFamilyDefault: true,- OllamaModel: "deepseek-v4-flash:0731:cloud",- },- {- ID: "claude-sonnet-5-20251001",- Type: "model",- DisplayName: "Qwen3.8 MLX",- CreatedAt: "2025-10-01T00:00:00Z",- MaxTokens: 64_000,- AnthropicFamilyTier: "sonnet",- IsFamilyDefault: false,- OllamaModel: "qwen3.8:27b-mlx",- },-}-type gatewayModel struct {ID string `json:"id"`Type string `json:"type"`@@ -104,13 +48,15 @@ type gatewayModel struct {// ClaudeDesktopConfig configures a Claude Desktop proxy instance.type ClaudeDesktopConfig struct {- ListenAddr string- OllamaURL string- Model string- Logger *slog.Logger- OnCountsChanged func(ClaudeDesktopCounts)- CloudModelsAvailable func(context.Context) bool- ListLocalModels func(context.Context) ([]string, error)+ ListenAddr string+ OllamaURL string+ Model string+ Models []ClaudeDesktopModel+ Logger *slog.Logger+ OnCountsChanged func(ClaudeDesktopCounts)+ RefreshModels func(context.Context, []ClaudeDesktopModel) ([]ClaudeDesktopModel, error)+ ResolveAccessState func(context.Context) (ClaudeDesktopAccessState, error)+ ListLocalModels func(context.Context) ([]string, error)}// ClaudeDesktopCounts reports requests routed through the proxy.@@ -128,17 +74,21 @@ type upstreamReadinessCheck struct {// proxy: Claude terminates its own gateway protocol here, so no TLS// interception or system trust changes are necessary.type ClaudeDesktop struct {- listenAddr string- ollamaURL *url.URL- ollamaProxy *httputil.ReverseProxy- logger *slog.Logger- model string- onCountsChanged func(ClaudeDesktopCounts)- cloudModelsAvailable func(context.Context) bool- listLocalModels func(context.Context) ([]string, error)- routed atomic.Uint64- shutdown chan struct{}- shutdownOnce sync.Once+ listenAddr string+ ollamaURL *url.URL+ ollamaProxy *httputil.ReverseProxy+ logger *slog.Logger+ model string+ modelsMu sync.RWMutex+ models []ClaudeDesktopModel+ modelsGeneration uint64+ onCountsChanged func(ClaudeDesktopCounts)+ refreshModels func(context.Context, []ClaudeDesktopModel) ([]ClaudeDesktopModel, error)+ resolveAccessState func(context.Context) (ClaudeDesktopAccessState, error)+ listLocalModels func(context.Context) ([]string, error)+ routed atomic.Uint64+ shutdown chan struct{}+ shutdownOnce sync.OncereadyMu sync.MutexreadyUntil time.Time@@ -179,16 +129,22 @@ func NewClaudeDesktop(config ClaudeDesktopConfig) (*ClaudeDesktop, error) {proxy.Transport = transportproxy.FlushInterval = -1p := &ClaudeDesktop{- listenAddr: config.ListenAddr,- ollamaURL: ollamaURL,- logger: logger,- model: config.Model,- onCountsChanged: config.OnCountsChanged,- cloudModelsAvailable: config.CloudModelsAvailable,- listLocalModels: config.ListLocalModels,- shutdown: make(chan struct{}),- readyWait: upstreamReadyTimeout,- readyPoll: upstreamReadyPoll,+ listenAddr: config.ListenAddr,+ ollamaURL: ollamaURL,+ logger: logger,+ model: config.Model,+ models: SelectClaudeDesktopModels(config.Models, nil),+ modelsGeneration: 1,+ onCountsChanged: config.OnCountsChanged,+ refreshModels: config.RefreshModels,+ resolveAccessState: config.ResolveAccessState,+ listLocalModels: config.ListLocalModels,+ shutdown: make(chan struct{}),+ readyWait: upstreamReadyTimeout,+ readyPoll: upstreamReadyPoll,+ }+ if len(p.models) == 0 {+ p.models = SelectClaudeDesktopModels(DefaultClaudeDesktopModels(), nil)}dialer := &net.Dialer{Timeout: upstreamReadyPoll}p.dial = dialer.DialContext@@ -198,7 +154,7 @@ func NewClaudeDesktop(config ClaudeDesktopConfig) (*ClaudeDesktop, error) {http.Error(w, "Ollama gateway unavailable", http.StatusBadGateway)}proxy.ModifyResponse = func(response *http.Response) error {- retried, err := retryWithoutUnsupportedImages(response, transport)+ retried, err := p.retryWithoutUnsupportedImages(response, transport)if err != nil {logger.Warn("Claude gateway image fallback failed", "path", response.Request.URL.Path, "error", err)return nil@@ -292,15 +248,62 @@ func (p *ClaudeDesktop) Counts() ClaudeDesktopCounts {return ClaudeDesktopCounts{Routed: p.routed.Load()}}+// Models returns the model subset currently advertised to Claude Desktop.+func (p *ClaudeDesktop) Models() []ClaudeDesktopModel {+ p.modelsMu.RLock()+ defer p.modelsMu.RUnlock()+ return cloneClaudeDesktopModels(p.models)+}++// SetModels replaces the complete model subset advertised to Claude Desktop.+func (p *ClaudeDesktop) SetModels(models []ClaudeDesktopModel) error {+ if len(models) == 0 {+ return errors.New("Claude Desktop requires at least one model")+ }+ models = SelectClaudeDesktopModels(models, nil)+ p.modelsMu.Lock()+ if claudeDesktopModelsEqual(p.models, models) {+ p.modelsMu.Unlock()+ return nil+ }+ p.models = cloneClaudeDesktopModels(models)+ p.model = models[0].OllamaModel+ p.modelsGeneration+++ p.modelsMu.Unlock()+ return nil+}++func (p *ClaudeDesktop) modelSnapshot() (string, []ClaudeDesktopModel) {+ p.modelsMu.RLock()+ defer p.modelsMu.RUnlock()+ return p.model, cloneClaudeDesktopModels(p.models)+}++func (p *ClaudeDesktop) modelSnapshotWithGeneration() (uint64, []ClaudeDesktopModel) {+ p.modelsMu.RLock()+ defer p.modelsMu.RUnlock()+ return p.modelsGeneration, cloneClaudeDesktopModels(p.models)+}++func claudeDesktopModelsEqual(left, right []ClaudeDesktopModel) bool {+ if len(left) != len(right) {+ return false+ }+ for i := range left {+ if left[i] != right[i] {+ return false+ }+ }+ return true+}+func (p *ClaudeDesktop) ServeHTTP(w http.ResponseWriter, r *http.Request) {if !p.allowsHost(r.Host) {http.Error(w, "forbidden", http.StatusForbidden)return}- model := p.model- switch r.URL.Path {- case healthPath:+ if r.URL.Path == healthPath {if r.Method != http.MethodGet {methodNotAllowed(w, http.MethodGet)return@@ -308,27 +311,41 @@ func (p *ClaudeDesktop) ServeHTTP(w http.ResponseWriter, r *http.Request) {w.Header().Set(healthHeader, "1")w.WriteHeader(http.StatusNoContent)return+ }+ generation, models := p.modelSnapshotWithGeneration()+ switch r.URL.Path {case "/v1/models":if r.Method != http.MethodGet {methodNotAllowed(w, http.MethodGet)return}- p.serveModels(w, r.Context())+ if hasCloudClaudeDesktopModel(models) {+ if err := p.refreshModelCatalog(r.Context()); err != nil {+ p.logger.Debug("could not refresh Claude model catalog", "error", err)+ }+ _, models = p.modelSnapshotWithGeneration()+ }+ p.serveModels(w, r.Context(), models)returncase "/v1/messages/count_tokens":if r.Method != http.MethodPost {methodNotAllowed(w, http.MethodPost)return}- p.serveTokenCount(w, r, model)+ p.serveTokenCount(w, r, generation, models)returncase "/v1/messages":if r.Method != http.MethodPost {methodNotAllowed(w, http.MethodPost)return}- if err := p.routeModel(r, model); err != nil {- writeAnthropicError(w, http.StatusBadRequest, err)+ if err := p.routeModel(r, generation, models); err != nil {+ var accessErr *claudeDesktopAccessError+ if errors.As(err, &accessErr) {+ writeAnthropicError(w, accessErr.status, accessErr)+ } else {+ writeAnthropicError(w, http.StatusBadRequest, err)+ }return}default:@@ -356,6 +373,42 @@ func (p *ClaudeDesktop) ServeHTTP(w http.ResponseWriter, r *http.Request) {p.ollamaProxy.ServeHTTP(w, r)}+func (p *ClaudeDesktop) refreshModelCatalog(ctx context.Context) error {+ if p.refreshModels == nil {+ return nil+ }+ generation, current := p.modelSnapshotWithGeneration()+ models, err := p.refreshModels(ctx, current)+ if err != nil {+ return err+ }+ if len(models) == 0 {+ return errors.New("Claude Desktop model refresh returned no models")+ }+ models = SelectClaudeDesktopModels(models, nil)+ p.modelsMu.Lock()+ defer p.modelsMu.Unlock()+ if p.modelsGeneration != generation {+ return nil+ }+ if claudeDesktopModelsEqual(p.models, models) {+ return nil+ }+ p.models = cloneClaudeDesktopModels(models)+ p.model = models[0].OllamaModel+ p.modelsGeneration+++ return nil+}++func hasCloudClaudeDesktopModel(models []ClaudeDesktopModel) bool {+ for _, model := range models {+ if model.Cloud {+ return true+ }+ }+ return false+}+func (p *ClaudeDesktop) allowsHost(host string) bool {_, listenerPort, err := net.SplitHostPort(p.Addr())if err != nil {@@ -456,35 +509,21 @@ func (p *ClaudeDesktop) markUpstreamNotReady() {p.readyMu.Unlock()}-func (p *ClaudeDesktop) serveModels(w http.ResponseWriter, ctx context.Context) {- cloudModelsAvailable := p.cloudModelsAvailable == nil || p.cloudModelsAvailable(ctx)+func (p *ClaudeDesktop) serveModels(w http.ResponseWriter, ctx context.Context, configured []ClaudeDesktopModel) {+ var state ClaudeDesktopAccessStatevar localModels map[string]struct{}- if p.listLocalModels != nil {- localModels = make(map[string]struct{})- names, err := p.listLocalModels(ctx)- if err != nil {- p.logger.Debug("could not list local models for Claude", "error", err)- } else {- for _, name := range names {- localModels[name] = struct{}{}- }- }- }-- models := make([]gatewayModel, 0, len(claudeModels))- for _, model := range claudeModels {- if modelref.HasExplicitCloudSource(model.OllamaModel) {- if cloudModelsAvailable {- models = append(models, model)- }- continue- }- if localModels == nil {- models = append(models, model)- continue- }- if _, ok := localModels[model.OllamaModel]; ok {- models = append(models, model)+ var inventoryKnown bool+ if hasCloudClaudeDesktopModel(configured) {+ state, localModels, inventoryKnown = p.accessFacts(ctx)+ } else {+ localModels, inventoryKnown = p.localModelFacts(ctx)+ }++ models := make([]gatewayModel, 0, len(configured))+ for _, configuredModel := range configured {+ access := evaluateClaudeDesktopAccess(configuredModel, state, localModels, inventoryKnown)+ if access.Availability == ClaudeDesktopAvailabilityAvailable {+ models = append(models, configuredModel.gateway)}}@@ -508,7 +547,7 @@ func (p *ClaudeDesktop) serveModels(w http.ResponseWriter, ctx context.Context)}}-func (p *ClaudeDesktop) serveTokenCount(w http.ResponseWriter, r *http.Request, model string) {+func (p *ClaudeDesktop) serveTokenCount(w http.ResponseWriter, r *http.Request, generation uint64, models []ClaudeDesktopModel) {body, err := readRequestBody(r)if err != nil {writeAnthropicError(w, http.StatusBadRequest, err)@@ -519,7 +558,25 @@ func (p *ClaudeDesktop) serveTokenCount(w http.ResponseWriter, r *http.Request,writeAnthropicError(w, http.StatusBadRequest, fmt.Errorf("decode Claude token-count request: %w", err))return}- selected := p.modelForClaudeID(request.Model, model)+ selected, err := claudeDesktopModelForID(models, request.Model)+ if err != nil {+ writeAnthropicError(w, http.StatusBadRequest, err)+ return+ }+ if selected.Cloud {+ if err := p.refreshModelCatalog(r.Context()); err != nil {+ p.logger.Debug("could not refresh Claude model catalog", "error", err)+ }+ }+ if !p.modelGenerationMatches(generation) {+ writeAnthropicError(w, http.StatusConflict, errors.New("Claude model catalog changed; try again"))+ return+ }+ if access := p.modelAccess(r.Context(), selected); access.Availability != ClaudeDesktopAvailabilityAvailable {+ accessErr := newClaudeDesktopAccessError(selected, access)+ writeAnthropicError(w, accessErr.status, accessErr)+ return+ }request.Model = selected.OllamaModelw.Header().Set("Content-Type", "application/json")if err := json.NewEncoder(w).Encode(anthropic.CountTokensResponse{@@ -529,7 +586,7 @@ func (p *ClaudeDesktop) serveTokenCount(w http.ResponseWriter, r *http.Request,}}-func (p *ClaudeDesktop) routeModel(r *http.Request, model string) error {+func (p *ClaudeDesktop) routeModel(r *http.Request, generation uint64, models []ClaudeDesktopModel) error {body, err := readRequestBody(r)if err != nil {return err@@ -542,7 +599,21 @@ func (p *ClaudeDesktop) routeModel(r *http.Request, model string) error {if err := json.Unmarshal(payload["model"], &requestedModel); err != nil || strings.TrimSpace(requestedModel) == "" {return errors.New("decode Claude gateway request: model is required")}- selected := p.modelForClaudeID(requestedModel, model)+ selected, err := claudeDesktopModelForID(models, requestedModel)+ if err != nil {+ return err+ }+ if selected.Cloud {+ if err := p.refreshModelCatalog(r.Context()); err != nil {+ p.logger.Debug("could not refresh Claude model catalog", "error", err)+ }+ }+ if !p.modelGenerationMatches(generation) {+ return errors.New("Claude model catalog changed; try again")+ }+ if access := p.modelAccess(r.Context(), selected); access.Availability != ClaudeDesktopAvailabilityAvailable {+ return newClaudeDesktopAccessError(selected, access)+ }targetModel := selected.OllamaModelif targetModel == requestedModel {setRequestBody(r, body)@@ -558,7 +629,7 @@ func (p *ClaudeDesktop) routeModel(r *http.Request, model string) error {return nil}-func retryWithoutUnsupportedImages(response *http.Response, transport http.RoundTripper) (bool, error) {+func (p *ClaudeDesktop) retryWithoutUnsupportedImages(response *http.Response, transport http.RoundTripper) (bool, error) {if response.StatusCode != http.StatusBadRequest || response.Request.Method != http.MethodPost || response.Request.URL.Path != "/v1/messages" || response.Request.GetBody == nil {return false, nil}@@ -587,7 +658,8 @@ func retryWithoutUnsupportedImages(response *http.Response, transport http.Roundif err := json.Unmarshal(payload["model"], &targetModel); err != nil {return false, nil}- selected, _ := gatewayModelForClaudeID(targetModel, targetModel)+ _, models := p.modelSnapshot()+ selected, _ := gatewayModelForOllamaModel(models, targetModel)if selected.SupportsVision {return false, nil}@@ -657,26 +729,118 @@ func setRequestBody(r *http.Request, body []byte) {r.Header.Set("Content-Length", fmt.Sprintf("%d", len(body)))}-func (p *ClaudeDesktop) modelForClaudeID(id, fallback string) gatewayModel {- model, known := gatewayModelForClaudeID(id, fallback)- if !known {- p.logger.Debug("Claude gateway using default for unknown model", "requested_model", id, "default_model", model.OllamaModel)+func (p *ClaudeDesktop) modelForClaudeID(id string) (ClaudeDesktopModel, error) {+ _, models := p.modelSnapshot()+ return claudeDesktopModelForID(models, id)+}++func claudeDesktopModelForID(models []ClaudeDesktopModel, id string) (ClaudeDesktopModel, error) {+ for _, model := range models {+ if model.gateway.ID == id || model.OllamaModel == id {+ return model, nil+ }}- return model+ return ClaudeDesktopModel{}, fmt.Errorf("unknown Claude model %q", id)+}++func (p *ClaudeDesktop) modelGenerationMatches(generation uint64) bool {+ p.modelsMu.RLock()+ defer p.modelsMu.RUnlock()+ return p.modelsGeneration == generation}-func gatewayModelForClaudeID(id, fallback string) (gatewayModel, bool) {- for _, model := range claudeModels {- if model.ID == id {- return model, true+func (p *ClaudeDesktop) accessFacts(ctx context.Context) (ClaudeDesktopAccessState, map[string]struct{}, bool) {+ state := ClaudeDesktopAccessState{+ Cloud: ClaudeDesktopCloudOn,+ Account: ClaudeDesktopAccountSignedIn,+ Plan: "pro",+ }+ if p.resolveAccessState != nil {+ resolved, err := p.resolveAccessState(ctx)+ state = resolved+ if err != nil {+ p.logger.Debug("could not resolve Claude model access", "error", err)}}- for _, model := range claudeModels {- if model.OllamaModel == fallback {- return model, false++ localModels, inventoryKnown := p.localModelFacts(ctx)+ return state, localModels, inventoryKnown+}++func (p *ClaudeDesktop) localModelFacts(ctx context.Context) (map[string]struct{}, bool) {+ if p.listLocalModels == nil {+ return nil, true+ }+ names, err := p.listLocalModels(ctx)+ if err != nil {+ p.logger.Debug("could not list local models for Claude", "error", err)+ return nil, false+ }+ localModels := make(map[string]struct{}, len(names))+ for _, name := range names {+ localModels[name] = struct{}{}+ }+ return localModels, true+}++func (p *ClaudeDesktop) modelAccess(ctx context.Context, model ClaudeDesktopModel) ClaudeDesktopModelAccess {+ if !model.Cloud {+ localModels, inventoryKnown := p.localModelFacts(ctx)+ return evaluateClaudeDesktopAccess(model, ClaudeDesktopAccessState{}, localModels, inventoryKnown)+ }+ state, localModels, inventoryKnown := p.accessFacts(ctx)+ return evaluateClaudeDesktopAccess(model, state, localModels, inventoryKnown)+}++func evaluateClaudeDesktopAccess(model ClaudeDesktopModel, state ClaudeDesktopAccessState, localModels map[string]struct{}, inventoryKnown bool) ClaudeDesktopModelAccess {+ _, installed := localModels[model.OllamaModel]+ if localModels == nil && inventoryKnown {+ installed = true+ }+ return EvaluateClaudeDesktopModelAccess(model, state, installed, inventoryKnown)+}++type claudeDesktopAccessError struct {+ status int+ model string+ access ClaudeDesktopModelAccess+}++func newClaudeDesktopAccessError(model ClaudeDesktopModel, access ClaudeDesktopModelAccess) *claudeDesktopAccessError {+ status := http.StatusForbidden+ switch access.Reason {+ case ClaudeDesktopAccessSignInRequired:+ status = http.StatusUnauthorized+ case ClaudeDesktopAccessModelNotInstalled:+ status = http.StatusNotFound+ case ClaudeDesktopAccessVerificationUnavailable:+ status = http.StatusServiceUnavailable+ }+ return &claudeDesktopAccessError{status: status, model: model.DisplayName, access: access}+}++func (e *claudeDesktopAccessError) Error() string {+ switch e.access.Reason {+ case ClaudeDesktopAccessCloudOff:+ return "Turn on Cloud in Ollama Settings to use this model."+ case ClaudeDesktopAccessSignInRequired:+ return "Sign in to Ollama to use this model."+ case ClaudeDesktopAccessUpgradeRequired:+ return fmt.Sprintf("%s requires an Ollama %s plan.", e.model, e.access.RequiredPlan)+ case ClaudeDesktopAccessModelNotInstalled:+ return fmt.Sprintf("%s is not installed in Ollama.", e.model)+ default:+ return "Ollama could not verify access to this model. Try again."+ }+}++func gatewayModelForOllamaModel(models []ClaudeDesktopModel, route string) (gatewayModel, bool) {+ for _, model := range models {+ if model.OllamaModel == route {+ return model.gateway, true}}- return gatewayModel{DisplayName: fallback, OllamaModel: fallback}, false+ return gatewayModel{}, false}func replaceUnsupportedImages(payload map[string]json.RawMessage) (bool, error) {diff --git a/internal/proxy/claude_desktop_access.go b/internal/proxy/claude_desktop_access.gonew file mode 100644index 000000000..bff908cc6--- /dev/null+++ b/internal/proxy/claude_desktop_access.go@@ -0,0 +1,124 @@+package proxy++import "strings"++type ClaudeDesktopCloudStatus string++const (+ ClaudeDesktopCloudUnknown ClaudeDesktopCloudStatus = "unknown"+ ClaudeDesktopCloudOff ClaudeDesktopCloudStatus = "off"+ ClaudeDesktopCloudOn ClaudeDesktopCloudStatus = "on"+)++type ClaudeDesktopAccountStatus string++const (+ ClaudeDesktopAccountUnknown ClaudeDesktopAccountStatus = "unknown"+ ClaudeDesktopAccountSignedOut ClaudeDesktopAccountStatus = "signed_out"+ ClaudeDesktopAccountSignedIn ClaudeDesktopAccountStatus = "signed_in"+)++// ClaudeDesktopAccessState is the current account and Cloud state used to+// evaluate Claude Desktop models. Callers should resolve it again at each user+// action or proxy request because both settings and account state can change.+type ClaudeDesktopAccessState struct {+ Cloud ClaudeDesktopCloudStatus+ Account ClaudeDesktopAccountStatus+ Plan string+}++type ClaudeDesktopAvailability string++const (+ ClaudeDesktopAvailabilityUnknown ClaudeDesktopAvailability = "unknown"+ ClaudeDesktopAvailabilityAvailable ClaudeDesktopAvailability = "available"+ ClaudeDesktopAvailabilityUnavailable ClaudeDesktopAvailability = "unavailable"+)++type ClaudeDesktopAccessReason string++const (+ ClaudeDesktopAccessCloudOff ClaudeDesktopAccessReason = "cloud_off"+ ClaudeDesktopAccessSignInRequired ClaudeDesktopAccessReason = "sign_in_required"+ ClaudeDesktopAccessUpgradeRequired ClaudeDesktopAccessReason = "upgrade_required"+ ClaudeDesktopAccessVerificationUnavailable ClaudeDesktopAccessReason = "verification_unavailable"+ ClaudeDesktopAccessModelNotInstalled ClaudeDesktopAccessReason = "model_not_installed"+)++// ClaudeDesktopModelAccess is the policy decision for one model.+type ClaudeDesktopModelAccess struct {+ Availability ClaudeDesktopAvailability+ Reason ClaudeDesktopAccessReason+ RequiredPlan string+}++// EvaluateClaudeDesktopModelAccess applies Claude Desktop's model policy to+// facts resolved by the app. installed and inventoryKnown only affect local+// models.+func EvaluateClaudeDesktopModelAccess(model ClaudeDesktopModel, state ClaudeDesktopAccessState, installed, inventoryKnown bool) ClaudeDesktopModelAccess {+ decision := ClaudeDesktopModelAccess{RequiredPlan: strings.TrimSpace(model.RequiredPlan)}+ if !model.Cloud {+ if !inventoryKnown {+ decision.Availability = ClaudeDesktopAvailabilityUnknown+ decision.Reason = ClaudeDesktopAccessVerificationUnavailable+ return decision+ }+ if installed {+ decision.Availability = ClaudeDesktopAvailabilityAvailable+ return decision+ }+ decision.Availability = ClaudeDesktopAvailabilityUnavailable+ decision.Reason = ClaudeDesktopAccessModelNotInstalled+ return decision+ }++ if state.Cloud == ClaudeDesktopCloudOff {+ decision.Availability = ClaudeDesktopAvailabilityUnavailable+ decision.Reason = ClaudeDesktopAccessCloudOff+ return decision+ }+ // A failed status check must not expose models that the local server may be+ // configured to reject. The next discovery or request evaluates again.+ if state.Cloud != ClaudeDesktopCloudOn {+ decision.Availability = ClaudeDesktopAvailabilityUnknown+ decision.Reason = ClaudeDesktopAccessVerificationUnavailable+ return decision+ }+ if state.Account == ClaudeDesktopAccountSignedOut {+ decision.Availability = ClaudeDesktopAvailabilityUnavailable+ decision.Reason = ClaudeDesktopAccessSignInRequired+ return decision+ }+ // Treat account lookup failures as recoverable instead of guessing that a+ // user is signed out or entitled to a paid model.+ if state.Account != ClaudeDesktopAccountSignedIn {+ decision.Availability = ClaudeDesktopAvailabilityUnknown+ decision.Reason = ClaudeDesktopAccessVerificationUnavailable+ return decision+ }+ if !model.entitlementKnown {+ decision.Availability = ClaudeDesktopAvailabilityUnknown+ decision.Reason = ClaudeDesktopAccessVerificationUnavailable+ return decision+ }+ if !claudeDesktopPlanSatisfies(state.Plan, decision.RequiredPlan) {+ decision.Availability = ClaudeDesktopAvailabilityUnavailable+ decision.Reason = ClaudeDesktopAccessUpgradeRequired+ return decision+ }++ decision.Availability = ClaudeDesktopAvailabilityAvailable+ return decision+}++func claudeDesktopPlanSatisfies(plan, required string) bool {+ plan = strings.ToLower(strings.TrimSpace(plan))+ required = strings.ToLower(strings.TrimSpace(required))+ // The recommendation contract currently has two access levels. Empty and+ // "free" are available to every signed-in account; any other requirement+ // needs a non-free account until the server exposes an ordered tier model.+ if required == "" || required == "free" {+ return true+ }+ return plan != "" && plan != "free"+}diff --git a/internal/proxy/claude_desktop_access_test.go b/internal/proxy/claude_desktop_access_test.gonew file mode 100644index 000000000..a09934b30--- /dev/null+++ b/internal/proxy/claude_desktop_access_test.go@@ -0,0 +1,66 @@+package proxy++import "testing"++func TestEvaluateClaudeDesktopModelAccess(t *testing.T) {+ local := newClaudeDesktopModel("qwen3:8b", "", "", 0)+ free := newClaudeDesktopModel("gemma4:31b-cloud", "", "free", 0)+ pro := newClaudeDesktopModel("glm-5.2:cloud", "", "pro", 0)++ tests := []struct {+ name string+ model ClaudeDesktopModel+ state ClaudeDesktopAccessState+ installed bool+ want ClaudeDesktopModelAccess+ }{+ {name: "installed local", model: local, installed: true, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityAvailable}},+ {name: "missing local", model: local, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnavailable, Reason: ClaudeDesktopAccessModelNotInstalled}},+ {name: "cloud off", model: free, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOff}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnavailable, Reason: ClaudeDesktopAccessCloudOff, RequiredPlan: "free"}},+ {name: "cloud unknown", model: free, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudUnknown}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnknown, Reason: ClaudeDesktopAccessVerificationUnavailable, RequiredPlan: "free"}},+ {name: "signed out", model: free, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedOut}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnavailable, Reason: ClaudeDesktopAccessSignInRequired, RequiredPlan: "free"}},+ {name: "account unknown", model: free, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountUnknown}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnknown, Reason: ClaudeDesktopAccessVerificationUnavailable, RequiredPlan: "free"}},+ {name: "free account free model", model: free, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "free"}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityAvailable, RequiredPlan: "free"}},+ {name: "free account pro model", model: pro, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "free"}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityUnavailable, Reason: ClaudeDesktopAccessUpgradeRequired, RequiredPlan: "pro"}},+ {name: "pro account pro model", model: pro, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "pro"}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityAvailable, RequiredPlan: "pro"}},+ {name: "future paid plan", model: pro, state: ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "enterprise"}, want: ClaudeDesktopModelAccess{Availability: ClaudeDesktopAvailabilityAvailable, RequiredPlan: "pro"}},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if got := EvaluateClaudeDesktopModelAccess(tt.model, tt.state, tt.installed, true); got != tt.want {+ t.Fatalf("EvaluateClaudeDesktopModelAccess() = %+v, want %+v", got, tt.want)+ }+ })+ }+}++func TestEvaluateClaudeDesktopModelAccessUnknownLocalInventory(t *testing.T) {+ model := newClaudeDesktopModel("qwen3:8b", "", "", 0)+ want := ClaudeDesktopModelAccess{+ Availability: ClaudeDesktopAvailabilityUnknown,+ Reason: ClaudeDesktopAccessVerificationUnavailable,+ }+ if got := EvaluateClaudeDesktopModelAccess(model, ClaudeDesktopAccessState{}, false, false); got != want {+ t.Fatalf("EvaluateClaudeDesktopModelAccess() = %+v, want %+v", got, want)+ }+}++func TestEvaluateClaudeDesktopModelAccessUnknownCloudEntitlement(t *testing.T) {+ selected := SelectClaudeDesktopModels(DefaultClaudeDesktopModels(), []string{"retired-pro-model:cloud"})+ if len(selected) != 1 {+ t.Fatalf("selected models = %d, want 1", len(selected))+ }+ want := ClaudeDesktopModelAccess{+ Availability: ClaudeDesktopAvailabilityUnknown,+ Reason: ClaudeDesktopAccessVerificationUnavailable,+ }+ state := ClaudeDesktopAccessState{+ Cloud: ClaudeDesktopCloudOn,+ Account: ClaudeDesktopAccountSignedIn,+ Plan: "free",+ }+ if got := EvaluateClaudeDesktopModelAccess(selected[0], state, false, true); got != want {+ t.Fatalf("EvaluateClaudeDesktopModelAccess() = %+v, want %+v", got, want)+ }+}diff --git a/internal/proxy/claude_desktop_models.go b/internal/proxy/claude_desktop_models.gonew file mode 100644index 000000000..c1978f400--- /dev/null+++ b/internal/proxy/claude_desktop_models.go@@ -0,0 +1,250 @@+package proxy++import (+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "io"+ "net/http"+ "strings"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/internal/modelref"+)++const (+ maxClaudeDesktopRecommendationsBody = 1 << 20+ MaxClaudeDesktopModels = 5+)++type claudeDesktopModelSlot struct {+ id string+ family string+ createdAt string+ familyDefault bool+}++var claudeDesktopModelSlots = [MaxClaudeDesktopModels]claudeDesktopModelSlot{+ {id: "claude-fable-5", family: "fable", createdAt: "2026-06-09T00:00:00Z", familyDefault: true},+ {id: "claude-opus-5", family: "opus", createdAt: "2026-07-24T00:00:00Z", familyDefault: true},+ {id: "claude-sonnet-5", family: "sonnet", createdAt: "2026-06-30T00:00:00Z", familyDefault: true},+ {id: "claude-haiku-4-5-20251001", family: "haiku", createdAt: "2025-10-01T00:00:00Z", familyDefault: true},+ {id: "claude-sonnet-4-6", family: "sonnet", createdAt: "2025-11-18T00:00:00Z"},+}++// ClaudeDesktopModel is one Ollama model adapted for Claude Desktop's model+// catalog. Name is the canonical recommendation identifier shown to users;+// OllamaModel is the explicit route sent to the local Ollama server.+type ClaudeDesktopModel struct {+ Name string+ Description string+ DisplayName string+ RequiredPlan string+ OllamaModel string+ Cloud bool+ entitlementKnown bool+ gateway gatewayModel+}++// GatewayID returns the validated Claude-facing ID assigned to this model.+func (m ClaudeDesktopModel) GatewayID() string {+ return m.gateway.ID+}++// FetchClaudeDesktopModels fetches the public app-aware recommendation+// contract. Callers are responsible for falling back when this fails.+func FetchClaudeDesktopModels(ctx context.Context, client *http.Client, endpoint string) ([]ClaudeDesktopModel, error) {+ if client == nil {+ return nil, errors.New("Claude Desktop recommendation client is required")+ }+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)+ if err != nil {+ return nil, fmt.Errorf("create Claude Desktop recommendation request: %w", err)+ }+ resp, err := client.Do(req)+ if err != nil {+ return nil, fmt.Errorf("fetch Claude Desktop recommendations: %w", err)+ }+ defer resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ _, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, maxClaudeDesktopRecommendationsBody))+ return nil, fmt.Errorf("fetch Claude Desktop recommendations: status %d", resp.StatusCode)+ }++ var payload api.ModelRecommendationsResponse+ decoder := json.NewDecoder(io.LimitReader(resp.Body, maxClaudeDesktopRecommendationsBody+1))+ if err := decoder.Decode(&payload); err != nil {+ return nil, fmt.Errorf("decode Claude Desktop recommendations: %w", err)+ }+ models := ClaudeDesktopModelsFromRecommendations(payload.Recommendations)+ cloudModels := models[:0]+ for _, model := range models {+ if model.Cloud {+ cloudModels = append(cloudModels, model)+ }+ }+ if len(cloudModels) == 0 {+ return nil, errors.New("Claude Desktop recommendations contain no cloud models")+ }+ return cloudModels, nil+}++// ClaudeDesktopModelsFromRecommendations converts the endpoint response into+// the protocol metadata Claude Desktop expects. Recommendation model names,+// order, descriptions, limits, and plan requirements remain server-owned.+func ClaudeDesktopModelsFromRecommendations(recommendations []api.ModelRecommendation) []ClaudeDesktopModel {+ models := make([]ClaudeDesktopModel, 0, len(recommendations))+ seen := make(map[string]struct{}, len(recommendations))+ for _, recommendation := range recommendations {+ name := strings.TrimSpace(recommendation.Model)+ if !validClaudeDesktopModelName(name) {+ continue+ }+ if _, ok := seen[name]; ok {+ continue+ }+ seen[name] = struct{}{}+ model := newClaudeDesktopModel(+ name,+ strings.TrimSpace(recommendation.Description),+ strings.TrimSpace(recommendation.RequiredPlan),+ recommendation.MaxOutputTokens,+ )+ model.entitlementKnown = true+ models = append(models, model)+ }+ return models+}++// DefaultClaudeDesktopModels is the built-in offline fallback. Keep this list+// deliberately small; the Ollama.com app-aware endpoint is the primary source.+func DefaultClaudeDesktopModels() []ClaudeDesktopModel {+ models := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", Description: "Long-horizon coding and agentic engineering", MaxOutputTokens: 128_000, RequiredPlan: "pro"},+ {Model: "kimi-k3:cloud", Description: "Long-horizon agentic reasoning with multimodal tool use", MaxOutputTokens: 262_144, RequiredPlan: "pro"},+ {Model: "deepseek-v4-pro", Description: "High-performance coding and tool use", MaxOutputTokens: 128_000, RequiredPlan: "pro"},+ {Model: "deepseek-v4-flash", Description: "Fast coding and agentic tool use", MaxOutputTokens: 64_000, RequiredPlan: "pro"},+ {Model: "gemma4:31b-cloud", Description: "Agentic workflows and multimodal reasoning", MaxOutputTokens: 262_144, RequiredPlan: "free"},+ })+ // Preserve the proven fallback route while the endpoint remains free to+ // move the canonical DeepSeek alias independently.+ models[3].OllamaModel = "deepseek-v4-flash:0731:cloud"+ models[3].DisplayName = models[3].OllamaModel+ models[3].gateway.DisplayName = models[3].OllamaModel+ models[3].gateway.OllamaModel = models[3].OllamaModel+ return models+}++// UnverifyClaudeDesktopCloudEntitlements prevents fallback metadata from+// overriding a catalog that was already refreshed from the server.+func UnverifyClaudeDesktopCloudEntitlements(models []ClaudeDesktopModel) []ClaudeDesktopModel {+ models = cloneClaudeDesktopModels(models)+ for i := range models {+ if models[i].Cloud {+ models[i].entitlementKnown = false+ }+ }+ return models+}++// SelectClaudeDesktopModels preserves the user's explicit order. Names that+// are no longer recommended remain usable so a transient endpoint change or+// outage cannot silently replace a saved user choice. Validated Claude IDs are+// reusable slots assigned in that order, independent of recommendation order.+func SelectClaudeDesktopModels(available []ClaudeDesktopModel, selected []string) []ClaudeDesktopModel {+ var models []ClaudeDesktopModel+ if len(selected) == 0 {+ models = cloneClaudeDesktopModels(available)+ } else {+ byName := make(map[string]ClaudeDesktopModel, len(available))+ for _, model := range available {+ byName[model.Name] = model+ byName[model.OllamaModel] = model+ }+ models = make([]ClaudeDesktopModel, 0, min(len(selected), MaxClaudeDesktopModels))+ seen := make(map[string]struct{}, len(selected))+ for _, rawName := range selected {+ if len(models) == MaxClaudeDesktopModels {+ break+ }+ name := strings.TrimSpace(rawName)+ if !validClaudeDesktopModelName(name) {+ continue+ }+ model, ok := byName[name]+ if !ok {+ model = newClaudeDesktopModel(name, "User-selected model", "", 64_000)+ }+ if _, ok := seen[model.OllamaModel]; ok {+ continue+ }+ seen[model.OllamaModel] = struct{}{}+ models = append(models, model)+ }+ }+ if len(models) > MaxClaudeDesktopModels {+ models = models[:MaxClaudeDesktopModels]+ }+ for i := range models {+ models[i].assignClaudeDesktopSlot(claudeDesktopModelSlots[i])+ }+ return models+}++func validClaudeDesktopModelName(name string) bool {+ name = strings.TrimSpace(name)+ if name == "" {+ return false+ }+ normalized := strings.NewReplacer("-", " ", ":", " ").Replace(strings.ToLower(name))+ normalized = strings.Join(strings.Fields(normalized), " ")+ return normalized != "ollama cloud"+}++func cloneClaudeDesktopModels(models []ClaudeDesktopModel) []ClaudeDesktopModel {+ return append([]ClaudeDesktopModel(nil), models...)+}++func newClaudeDesktopModel(name, description, requiredPlan string, maxTokens int) ClaudeDesktopModel {+ ollamaModel := name+ // The app-aware recommendation contract uses required_plan for cloud aliases+ // that intentionally omit a source suffix, such as DeepSeek. Installed local+ // models are added separately and never carry plan requirements.+ cloud := requiredPlan != "" || modelref.HasExplicitCloudSource(ollamaModel)+ if cloud && !modelref.HasExplicitCloudSource(ollamaModel) {+ ollamaModel += ":cloud"+ }+ displayName := ollamaModel+ if maxTokens <= 0 {+ maxTokens = 64_000+ }++ model := ClaudeDesktopModel{+ Name: name,+ Description: description,+ DisplayName: displayName,+ RequiredPlan: requiredPlan,+ OllamaModel: ollamaModel,+ Cloud: cloud,+ // Local models are checked against installed inventory. A cloud model+ // constructed without plan metadata must be verified by an authoritative+ // recommendation before account policy can allow it.+ entitlementKnown: !cloud || strings.TrimSpace(requiredPlan) != "",+ gateway: gatewayModel{+ Type: "model",+ DisplayName: displayName,+ MaxTokens: maxTokens,+ OllamaModel: ollamaModel,+ SupportsVision: name == "kimi-k3:cloud",+ },+ }+ return model+}++func (m *ClaudeDesktopModel) assignClaudeDesktopSlot(slot claudeDesktopModelSlot) {+ m.gateway.ID = slot.id+ m.gateway.CreatedAt = slot.createdAt+ m.gateway.AnthropicFamilyTier = slot.family+ m.gateway.IsFamilyDefault = slot.familyDefault+}diff --git a/internal/proxy/claude_desktop_models_test.go b/internal/proxy/claude_desktop_models_test.gonew file mode 100644index 000000000..5507be1ba--- /dev/null+++ b/internal/proxy/claude_desktop_models_test.go@@ -0,0 +1,259 @@+package proxy++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "slices"+ "strings"+ "testing"++ "github.com/ollama/ollama/api"+)++func TestFetchClaudeDesktopModelsUsesAppAwareContract(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.Method != http.MethodGet || r.URL.Path != "/api/experimental/model-recommendations" {+ t.Fatalf("request = %s %s", r.Method, r.URL.Path)+ }+ if got := r.URL.Query().Get("app"); got != "claude-desktop" {+ t.Fatalf("app = %q, want claude-desktop", got)+ }+ _ = json.NewEncoder(w).Encode(api.ModelRecommendationsResponse{Recommendations: []api.ModelRecommendation{+ {Model: "glm-5.2:cloud", Description: "GLM", MaxOutputTokens: 131_072, RequiredPlan: "pro"},+ {Model: "deepseek-v4-pro", Description: "DeepSeek", MaxOutputTokens: 65_536, RequiredPlan: "pro"},+ {Model: "qwen3.8:27b", Description: "Qwen", MaxOutputTokens: 131_072},+ }})+ }))+ defer server.Close()++ models, err := FetchClaudeDesktopModels(context.Background(), server.Client(), server.URL+"/api/experimental/model-recommendations?app=claude-desktop")+ if err != nil {+ t.Fatal(err)+ }+ if got, want := claudeDesktopModelNames(models), []string{"glm-5.2:cloud", "deepseek-v4-pro"}; !slices.Equal(got, want) {+ t.Fatalf("models = %v, want %v", got, want)+ }+ if models[1].OllamaModel != "deepseek-v4-pro:cloud" || !models[1].Cloud {+ t.Fatalf("cloud adapter = %+v", models[1])+ }+ if models[1].DisplayName != "deepseek-v4-pro:cloud" {+ t.Fatalf("display name = %q, want exact model identifier", models[1].DisplayName)+ }+}++func TestFetchClaudeDesktopModelsRejectsInvalidResponses(t *testing.T) {+ for _, test := range []struct {+ name string+ status int+ body string+ }{+ {name: "server error", status: http.StatusBadGateway, body: `{"error":"unavailable"}`},+ {name: "malformed", status: http.StatusOK, body: `{`},+ {name: "empty", status: http.StatusOK, body: `{"recommendations":[]}`},+ {name: "local only", status: http.StatusOK, body: `{"recommendations":[{"model":"qwen3.8:27b"}]}`},+ } {+ t.Run(test.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(test.status)+ _, _ = w.Write([]byte(test.body))+ }))+ defer server.Close()+ if _, err := FetchClaudeDesktopModels(context.Background(), server.Client(), server.URL); err == nil {+ t.Fatal("FetchClaudeDesktopModels succeeded")+ }+ })+ }+}++func TestDefaultClaudeDesktopModelsExcludeMLX(t *testing.T) {+ models := DefaultClaudeDesktopModels()+ if got, want := claudeDesktopModelNames(models), []string{"glm-5.2:cloud", "kimi-k3:cloud", "deepseek-v4-pro", "deepseek-v4-flash", "gemma4:31b-cloud"}; !slices.Equal(got, want) {+ t.Fatalf("fallback models = %v, want %v", got, want)+ }+ for _, model := range models {+ if strings.Contains(strings.ToLower(model.Name), "mlx") {+ t.Fatalf("fallback contains MLX model %q", model.Name)+ }+ }+ if models[3].OllamaModel != "deepseek-v4-flash:0731:cloud" {+ t.Fatalf("fallback Flash route = %q", models[3].OllamaModel)+ }+}++func TestSelectClaudeDesktopModelsPrioritizesExplicitSelection(t *testing.T) {+ available := DefaultClaudeDesktopModels()+ selected := SelectClaudeDesktopModels(available, []string{"deepseek-v4-flash", "glm-5.2:cloud"})+ if got, want := claudeDesktopModelNames(selected), []string{"deepseek-v4-flash", "glm-5.2:cloud"}; !slices.Equal(got, want) {+ t.Fatalf("selected models = %v, want %v", got, want)+ }++ cloudRoute := SelectClaudeDesktopModels(available, []string{"deepseek-v4-flash:0731:cloud"})+ if len(cloudRoute) != 1 || cloudRoute[0].Name != "deepseek-v4-flash" || cloudRoute[0].OllamaModel != "deepseek-v4-flash:0731:cloud" || !cloudRoute[0].Cloud {+ t.Fatalf("cloud route selection = %+v", cloudRoute)+ }++ custom := SelectClaudeDesktopModels(available, []string{"custom-model"})+ if len(custom) != 1 || custom[0].Name != "custom-model" || custom[0].OllamaModel != "custom-model" {+ t.Fatalf("custom selection = %+v", custom)+ }+ if got, want := custom[0].GatewayID(), "claude-fable-5"; got != want {+ t.Fatalf("custom gateway ID = %q, want validated slot %q", got, want)+ }++ withoutSentinel := SelectClaudeDesktopModels(available, []string{"Ollama Cloud", "ollama:cloud", "qwen3:8b"})+ if got, want := claudeDesktopModelNames(withoutSentinel), []string{"qwen3:8b"}; !slices.Equal(got, want) {+ t.Fatalf("selection without invalid sentinel = %v, want %v", got, want)+ }+}++func claudeDesktopModelNames(models []ClaudeDesktopModel) []string {+ names := make([]string, len(models))+ for i, model := range models {+ names[i] = model.Name+ }+ return names+}++func TestSelectClaudeDesktopModelsAssignsValidatedClaudeIDs(t *testing.T) {+ available := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ {Model: "deepseek-v4-pro", RequiredPlan: "pro"},+ {Model: "deepseek-v4-flash", RequiredPlan: "pro"},+ {Model: "gemma4:26b:cloud", RequiredPlan: "pro"},+ })+ selected := SelectClaudeDesktopModels(available, []string{+ "glm-5.2:cloud",+ "kimi-k3:cloud",+ "deepseek-v4-pro",+ "deepseek-v4-flash",+ "gemma4:26b:cloud",+ })+ if len(selected) != 5 {+ t.Fatalf("selected models = %v", claudeDesktopModelNames(selected))+ }+ wantIDs := []string{+ "claude-fable-5",+ "claude-opus-5",+ "claude-sonnet-5",+ "claude-haiku-4-5-20251001",+ "claude-sonnet-4-6",+ }+ seen := make(map[string]struct{}, len(selected))+ for i, model := range selected {+ id := model.GatewayID()+ if id != wantIDs[i] {+ t.Fatalf("gateway ID %d = %q, want literal slot %q", i, id, wantIDs[i])+ }+ if _, ok := seen[id]; ok {+ t.Fatalf("duplicate gateway ID %q in %v", id, selected)+ }+ seen[id] = struct{}{}+ }++ // Custom installed models use the same validated slots while preserving the+ // Ollama route separately.+ withCustom := SelectClaudeDesktopModels(available, []string{"kimi-k3:cloud", "mycustommodel:7b"})+ if len(withCustom) != 2 || withCustom[1].Name != "mycustommodel:7b" {+ t.Fatalf("custom selection = %v", claudeDesktopModelNames(withCustom))+ }+ if got, want := withCustom[1].GatewayID(), "claude-opus-5"; got != want {+ t.Fatalf("custom gateway ID = %q, want validated slot %q", got, want)+ }+ if withCustom[1].OllamaModel != "mycustommodel:7b" {+ t.Fatalf("custom Ollama route = %q", withCustom[1].OllamaModel)+ }++ // Reordering the persisted selection reassigns the slots in that same order.+ // The gateway catalog and request router consume this one mapping together.+ merged := append(append([]ClaudeDesktopModel(nil), available...), withCustom[1])+ reordered := SelectClaudeDesktopModels(merged, []string{"mycustommodel:7b", "kimi-k3:cloud"})+ if len(reordered) != 2 || reordered[0].GatewayID() != "claude-fable-5" || reordered[1].GatewayID() != "claude-opus-5" {+ t.Fatalf("reordered gateway IDs = %q/%q", reordered[0].GatewayID(), reordered[1].GatewayID())+ }+}++func TestSelectClaudeDesktopModelsIgnoresRecommendationReordering(t *testing.T) {+ first := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ })+ second := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ })+ persisted := []string{"glm-5.2:cloud", "kimi-k3:cloud"}++ for _, available := range [][]ClaudeDesktopModel{first, second} {+ selected := SelectClaudeDesktopModels(available, persisted)+ if len(selected) != 2 {+ t.Fatalf("selected models = %+v", selected)+ }+ if selected[0].OllamaModel != "glm-5.2:cloud" || selected[0].GatewayID() != "claude-fable-5" {+ t.Fatalf("GLM mapping = %q -> %q", selected[0].GatewayID(), selected[0].OllamaModel)+ }+ if selected[1].OllamaModel != "kimi-k3:cloud" || selected[1].GatewayID() != "claude-opus-5" {+ t.Fatalf("Kimi mapping = %q -> %q", selected[1].GatewayID(), selected[1].OllamaModel)+ }+ }+}++func TestSelectClaudeDesktopModelsCapsAtLiteralSlots(t *testing.T) {+ available := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ {Model: "deepseek-v4-pro", RequiredPlan: "pro"},+ {Model: "deepseek-v4-flash", RequiredPlan: "pro"},+ {Model: "gemma4:26b:cloud", RequiredPlan: "pro"},+ {Model: "qwen3.8:27b", RequiredPlan: ""},+ })+ if len(available) != 6 {+ t.Fatalf("catalog = %d models, want 6", len(available))+ }+ if available[5].GatewayID() != "" {+ t.Fatalf("unselected catalog entry ID = %q, want no assigned slot", available[5].GatewayID())+ }++ // Without an explicit selection the first five recommendations apply.+ defaults := SelectClaudeDesktopModels(available, nil)+ if len(defaults) != MaxClaudeDesktopModels {+ t.Fatalf("default selection = %d models, want %d", len(defaults), MaxClaudeDesktopModels)+ }++ // Any recommendation can be selected explicitly even beyond the default five.+ qwen := SelectClaudeDesktopModels(available, []string{"kimi-k3:cloud", "qwen3.8:27b"})+ if len(qwen) != 2 || qwen[1].GatewayID() != "claude-opus-5" || qwen[1].OllamaModel != "qwen3.8:27b" {+ t.Fatalf("unmapped catalog selection = %+v", qwen)+ }++ // Selections never exceed the five literal slots.+ tooMany := SelectClaudeDesktopModels(available, []string{+ "glm-5.2:cloud",+ "kimi-k3:cloud",+ "deepseek-v4-pro",+ "deepseek-v4-flash",+ "gemma4:26b:cloud",+ "qwen3.8:27b",+ })+ if len(tooMany) != MaxClaudeDesktopModels {+ t.Fatalf("capped selection = %d models, want %d", len(tooMany), MaxClaudeDesktopModels)+ }+ for _, name := range claudeDesktopModelNames(tooMany) {+ if name == "qwen3.8:27b" {+ t.Fatalf("sixth selection %q survived the cap", name)+ }+ }+ seen := make(map[string]struct{}, len(tooMany))+ for _, model := range tooMany {+ id := model.GatewayID()+ if id == "" {+ t.Fatalf("selected model %q has no Claude ID", model.Name)+ }+ if _, ok := seen[id]; ok {+ t.Fatalf("duplicate gateway ID %q", id)+ }+ seen[id] = struct{}{}+ }+}diff --git a/internal/proxy/claude_desktop_test.go b/internal/proxy/claude_desktop_test.goindex 15ae385a4..7086758bd 100644--- a/internal/proxy/claude_desktop_test.go+++ b/internal/proxy/claude_desktop_test.go@@ -1,12 +1,10 @@package proxyimport (- "bytes""context""encoding/json""errors""io"- "log/slog""net""net/http""net/http/httptest"@@ -16,6 +14,7 @@ import ("time""github.com/ollama/ollama/anthropic"+ "github.com/ollama/ollama/api")func TestGatewayRoutesClaudeProtocolToOllama(t *testing.T) {@@ -45,12 +44,10 @@ func TestGatewayRoutesClaudeProtocolToOllama(t *testing.T) {body string}{{http.MethodGet, "/v1/models?limit=1000", ""},- {http.MethodPost, "/v1/messages", `{"model":"claude-fable-5","messages":[]}`},- {http.MethodPost, "/v1/messages", `{"model":"claude-opus-5","messages":[]}`},- {http.MethodPost, "/v1/messages", `{"model":"claude-sonnet-5","messages":[]}`},- {http.MethodPost, "/v1/messages", `{"model":"claude-haiku-4-5-20251001","messages":[]}`},- {http.MethodPost, "/v1/messages", `{"model":"claude-sonnet-5-20251001","messages":[]}`},- {http.MethodPost, "/v1/messages", `{"model":"claude-opus-4-6","messages":[]}`},+ {http.MethodPost, "/v1/messages", `{"model":"glm-5.2:cloud","messages":[]}`},+ {http.MethodPost, "/v1/messages", `{"model":"kimi-k3:cloud","messages":[]}`},+ {http.MethodPost, "/v1/messages", `{"model":"deepseek-v4-pro:cloud","messages":[]}`},+ {http.MethodPost, "/v1/messages", `{"model":"deepseek-v4-flash:0731:cloud","messages":[]}`},} {req, err := http.NewRequest(request.method, "http://"+p.Addr()+request.path, strings.NewReader(request.body))if err != nil {@@ -93,30 +90,18 @@ func TestGatewayRoutesClaudeProtocolToOllama(t *testing.T) {}gotIDs := make([]string, len(catalog.Data))gotNames := make([]string, len(catalog.Data))- familyDefaults := make(map[string]int)for i, model := range catalog.Data {gotIDs[i] = model.IDgotNames[i] = model.DisplayName- if model.Type != "model" || model.AnthropicFamilyTier == "" {+ if model.Type != "model" {t.Fatalf("incomplete gateway model metadata: %+v", model)}- if model.IsFamilyDefault {- familyDefaults[model.AnthropicFamilyTier]++- }- if model.ID == "claude-sonnet-5-20251001" && model.AnthropicFamilyTier != "sonnet" {- t.Fatalf("Qwen family tier = %q, want sonnet", model.AnthropicFamilyTier)- }- }- for _, family := range []string{"opus", "fable", "sonnet", "haiku"} {- if familyDefaults[family] != 1 {- t.Fatalf("%s family defaults = %d, want 1", family, familyDefaults[family])- }}- wantIDs := "claude-fable-5,claude-opus-5,claude-sonnet-5,claude-haiku-4-5-20251001,claude-sonnet-5-20251001"+ wantIDs := "claude-fable-5,claude-opus-5,claude-sonnet-5,claude-haiku-4-5-20251001,claude-sonnet-4-6"if strings.Join(gotIDs, ",") != wantIDs || catalog.FirstID != gotIDs[0] || catalog.LastID != gotIDs[len(gotIDs)-1] || catalog.HasMore {t.Fatalf("gateway catalog = %+v", catalog.Data)}- wantNames := "GLM 5.2,Kimi K3,DeepSeek V4 Pro,DeepSeek V4 Flash,Qwen3.8 MLX"+ wantNames := "glm-5.2:cloud,kimi-k3:cloud,deepseek-v4-pro:cloud,deepseek-v4-flash:0731:cloud,gemma4:31b-cloud"if strings.Join(gotNames, ",") != wantNames {t.Fatalf("gateway display names = %v, want %s", gotNames, wantNames)}@@ -129,17 +114,169 @@ func TestGatewayRoutesClaudeProtocolToOllama(t *testing.T) {"kimi-k3:cloud","deepseek-v4-pro:cloud","deepseek-v4-flash:0731:cloud",- "qwen3.8:27b-mlx",- "glm-5.2:cloud",}if strings.Join(messageModels, ",") != strings.Join(wantModels, ",") {t.Fatalf("rewritten message models = %v", messageModels)}- if len(paths) != 6 {+ if len(paths) != 4 {t.Fatalf("upstream paths = %v", paths)}- if got := p.Counts().Routed; got != 6 {- t.Fatalf("routed requests = %d, want 6", got)+ if got := p.Counts().Routed; got != 4 {+ t.Fatalf("routed requests = %d, want 4", got)+ }+}++func TestGatewayRoutesSelectedKimiByExactRoute(t *testing.T) {+ var routedModel string+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ routedModel = requestModel(t, r)+ w.Header().Set("Content-Type", "application/json")+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()++ selected := SelectClaudeDesktopModels(DefaultClaudeDesktopModels(), []string{"kimi-k3:cloud"})+ if len(selected) != 1 || selected[0].GatewayID() != "claude-fable-5" || selected[0].OllamaModel != "kimi-k3:cloud" {+ t.Fatalf("selected kimi = %+v, want validated ID routing to exact model", selected)+ }+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: selected[0].OllamaModel,+ Models: selected,+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ if err := p.Close(ctx); err != nil {+ t.Fatal(err)+ }+ })++ resp, err := http.Get("http://" + p.Addr() + "/v1/models")+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ var catalog struct {+ Data []gatewayModel `json:"data"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&catalog); err != nil {+ t.Fatal(err)+ }+ if len(catalog.Data) != 1 || catalog.Data[0].ID != "claude-fable-5" || catalog.Data[0].DisplayName != "kimi-k3:cloud" {+ t.Fatalf("catalog = %+v, want claude-fable-5 displaying Kimi", catalog.Data)+ }++ message, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"claude-fable-5","messages":[{"role":"user","content":"hi"}]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ defer message.Body.Close()+ if message.StatusCode != http.StatusOK || routedModel != "kimi-k3:cloud" {+ t.Fatalf("status/model = %d/%q, want 200 routing kimi-k3:cloud", message.StatusCode, routedModel)+ }+}++func TestGatewayRoutesEveryMappedModelIDToExactOllamaRoute(t *testing.T) {+ var routed []string+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ routed = append(routed, requestModel(t, r))+ w.Header().Set("Content-Type", "application/json")+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()++ models := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ {Model: "deepseek-v4-pro", RequiredPlan: "pro"},+ {Model: "deepseek-v4-flash", RequiredPlan: "pro"},+ {Model: "gemma4:26b:cloud", RequiredPlan: "pro"},+ })+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: models[0].OllamaModel,+ Models: models,+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ if err := p.Close(ctx); err != nil {+ t.Fatal(err)+ }+ })++ routes := []struct {+ id string+ ollama string+ }{+ {"claude-fable-5", "glm-5.2:cloud"},+ {"claude-opus-5", "kimi-k3:cloud"},+ {"claude-sonnet-5", "deepseek-v4-pro:cloud"},+ {"claude-haiku-4-5-20251001", "deepseek-v4-flash:cloud"},+ {"claude-sonnet-4-6", "gemma4:26b:cloud"},+ }+ for _, route := range routes {+ resp, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"`+route.id+`","messages":[{"role":"user","content":"hi"}]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ if resp.StatusCode != http.StatusOK {+ _ = resp.Body.Close()+ t.Fatalf("%s status = %d, want 200", route.id, resp.StatusCode)+ }+ _ = resp.Body.Close()+ if got := routed[len(routed)-1]; got != route.ollama {+ t.Fatalf("%s routed to %q, want exact Ollama route %q", route.id, got, route.ollama)+ }+ }++ resp, err := http.Get("http://" + p.Addr() + "/v1/models")+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ var catalog struct {+ Data []gatewayModel `json:"data"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&catalog); err != nil {+ t.Fatal(err)+ }+ gotIDs := make([]string, len(catalog.Data))+ for i, model := range catalog.Data {+ gotIDs[i] = model.ID+ }+ wantIDs := []string{+ "claude-fable-5",+ "claude-opus-5",+ "claude-sonnet-5",+ "claude-haiku-4-5-20251001",+ "claude-sonnet-4-6",+ }+ if strings.Join(gotIDs, ",") != strings.Join(wantIDs, ",") {+ t.Fatalf("catalog IDs = %v, want validated Claude IDs %v", gotIDs, wantIDs)}}@@ -149,14 +286,26 @@ func TestGatewayPrunesCloudModelsWhenSignedOut(t *testing.T) {var cloudModelsAvailable atomic.Boolvar localModelAvailable atomic.Bool+ models := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "kimi-k3:cloud", RequiredPlan: "pro"},+ {Model: "qwen3.8:27b"},+ })p, err := NewClaudeDesktop(ClaudeDesktopConfig{- ListenAddr: "127.0.0.1:0",- OllamaURL: upstream.URL,- Model: "kimi-k3:cloud",- CloudModelsAvailable: func(context.Context) bool { return cloudModelsAvailable.Load() },+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: "kimi-k3:cloud",+ Models: models,+ ResolveAccessState: func(context.Context) (ClaudeDesktopAccessState, error) {+ state := ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedOut}+ if cloudModelsAvailable.Load() {+ state.Account = ClaudeDesktopAccountSignedIn+ state.Plan = "pro"+ }+ return state, nil+ },ListLocalModels: func(context.Context) ([]string, error) {if localModelAvailable.Load() {- return []string{"qwen3.8:27b-mlx"}, nil+ return []string{"qwen3.8:27b"}, nil}return nil, nil},@@ -206,7 +355,7 @@ func TestGatewayPrunesCloudModelsWhenSignedOut(t *testing.T) {localModelAvailable.Store(true)catalog = fetchCatalog()- if len(catalog.Data) != 1 || catalog.Data[0].DisplayName != "Qwen3.8 MLX" {+ if len(catalog.Data) != 1 || catalog.Data[0].DisplayName != "qwen3.8:27b" {t.Fatalf("signed-out catalog = %+v, want local model only", catalog.Data)}if catalog.FirstID != catalog.Data[0].ID || catalog.LastID != catalog.Data[0].ID {@@ -215,8 +364,422 @@ func TestGatewayPrunesCloudModelsWhenSignedOut(t *testing.T) {cloudModelsAvailable.Store(true)catalog = fetchCatalog()- if len(catalog.Data) != len(claudeModels) {- t.Fatalf("signed-in catalog has %d models, want %d", len(catalog.Data), len(claudeModels))+ if len(catalog.Data) != len(models) {+ t.Fatalf("signed-in catalog has %d models, want %d", len(catalog.Data), len(models))+ }+}++func TestGatewayReevaluatesModelAccessBeforeRouting(t *testing.T) {+ var routed atomic.Int64+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ routed.Add(1)+ w.Header().Set("Content-Type", "application/json")+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()++ state := ClaudeDesktopAccessState{+ Cloud: ClaudeDesktopCloudOn,+ Account: ClaudeDesktopAccountSignedIn,+ Plan: "free",+ }+ models := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "gemma4:31b-cloud", RequiredPlan: "free"},+ })+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: models[0].OllamaModel,+ Models: models,+ ResolveAccessState: func(context.Context) (ClaudeDesktopAccessState, error) {+ return state, nil+ },+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ if err := p.Close(ctx); err != nil {+ t.Fatal(err)+ }+ })++ postMessage := func(model string) (int, string) {+ t.Helper()+ resp, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"`+model+`","messages":[{"role":"user","content":"hi"}]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ body, err := io.ReadAll(resp.Body)+ if err != nil {+ t.Fatal(err)+ }+ return resp.StatusCode, string(body)+ }+ assertMessage := func(model string, status int, want string) {+ t.Helper()+ gotStatus, body := postMessage(model)+ if gotStatus != status || !strings.Contains(body, want) {+ t.Fatalf("status/body = %d/%q, want %d containing %q", gotStatus, body, status, want)+ }+ }++ assertMessage("claude-fable-5", http.StatusForbidden, "requires an Ollama pro plan")+ if routed.Load() != 0 {+ t.Fatalf("ineligible Pro request reached upstream")+ }++ assertMessage("claude-opus-5", http.StatusOK, `"ok":true`)+ if routed.Load() != 1 {+ t.Fatalf("free model routed %d times, want 1", routed.Load())+ }++ // Account and Cloud settings can change while Claude is open. Each request+ // resolves them again so an old conversation cannot retain stale access.+ state.Cloud = ClaudeDesktopCloudOff+ assertMessage("claude-opus-5", http.StatusForbidden, "Turn on Cloud in Ollama Settings")+ if routed.Load() != 1 {+ t.Fatalf("Cloud-disabled request reached upstream")+ }+}++func assertResponseContains(t *testing.T, response *http.Response, status int, want string) {+ t.Helper()+ defer response.Body.Close()+ body, err := io.ReadAll(response.Body)+ if err != nil {+ t.Fatal(err)+ }+ if response.StatusCode != status || !strings.Contains(string(body), want) {+ t.Fatalf("response = %d %s, want %d containing %q", response.StatusCode, body, status, want)+ }+}++func TestGatewaySetModelsReplacesCatalogAndRoutesExactModel(t *testing.T) {+ var routedModel string+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ routedModel = requestModel(t, r)+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()+ p := startTestGateway(t, upstream.URL)++ available := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{+ {Model: "glm-5.2:cloud", RequiredPlan: "pro"},+ {Model: "qwen3.8:27b"},+ })+ selected := SelectClaudeDesktopModels(available, []string{"qwen3.8:27b"})+ if err := p.SetModels(selected); err != nil {+ t.Fatal(err)+ }++ resp, err := http.Get("http://" + p.Addr() + "/v1/models")+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ var catalog struct {+ Data []gatewayModel `json:"data"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&catalog); err != nil {+ t.Fatal(err)+ }+ if len(catalog.Data) != 1 || catalog.Data[0].DisplayName != "qwen3.8:27b" {+ t.Fatalf("catalog = %+v", catalog.Data)+ }++ message, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"qwen3.8:27b","messages":[]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ defer message.Body.Close()+ if message.StatusCode != http.StatusOK || routedModel != "qwen3.8:27b" {+ t.Fatalf("status/model = %d/%q", message.StatusCode, routedModel)+ }+}++func TestGatewayRefreshesEntitlementsWithoutRestart(t *testing.T) {+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()+ initial := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "changing-model:cloud", RequiredPlan: "free"}})+ updated := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "changing-model:cloud", RequiredPlan: "pro"}})+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: initial[0].OllamaModel,+ Models: initial,+ RefreshModels: func(context.Context, []ClaudeDesktopModel) ([]ClaudeDesktopModel, error) {+ return updated, nil+ },+ ResolveAccessState: func(context.Context) (ClaudeDesktopAccessState, error) {+ return ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "free"}, nil+ },+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ _ = p.Close(ctx)+ })++ resp, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"claude-fable-5","messages":[]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ assertResponseContains(t, resp, http.StatusBadRequest, "model catalog changed")++ resp, err = http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"claude-fable-5","messages":[]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ assertResponseContains(t, resp, http.StatusForbidden, "requires an Ollama pro plan")+}++func TestGatewayDiscardsRefreshThatRacesWithModelUpdate(t *testing.T) {+ initial := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "model-a:cloud", RequiredPlan: "free"}})+ updated := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "model-b:cloud", RequiredPlan: "free"}})+ started := make(chan struct{})+ release := make(chan struct{})+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: "http://127.0.0.1:11434",+ Model: initial[0].OllamaModel,+ Models: initial,+ RefreshModels: func(_ context.Context, current []ClaudeDesktopModel) ([]ClaudeDesktopModel, error) {+ close(started)+ <-release+ return current, nil+ },+ })+ if err != nil {+ t.Fatal(err)+ }+ done := make(chan error, 1)+ go func() { done <- p.refreshModelCatalog(context.Background()) }()+ <-started+ if err := p.SetModels(updated); err != nil {+ t.Fatal(err)+ }+ close(release)+ if err := <-done; err != nil {+ t.Fatal(err)+ }+ models := p.Models()+ if len(models) != 1 || models[0].OllamaModel != "model-b:cloud" {+ t.Fatalf("models after racing refresh = %+v, want model B", models)+ }+}++func TestGatewayRejectsRequestWhenSlotChangesDuringRefresh(t *testing.T) {+ var upstreamCalls atomic.Int32+ upstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {+ upstreamCalls.Add(1)+ }))+ defer upstream.Close()+ initial := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "model-a:cloud", RequiredPlan: "free"}})+ updated := ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "model-b:cloud", RequiredPlan: "free"}})+ started := make(chan struct{})+ release := make(chan struct{})+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: initial[0].OllamaModel,+ Models: initial,+ RefreshModels: func(_ context.Context, current []ClaudeDesktopModel) ([]ClaudeDesktopModel, error) {+ close(started)+ <-release+ return current, nil+ },+ ResolveAccessState: func(context.Context) (ClaudeDesktopAccessState, error) {+ return ClaudeDesktopAccessState{Cloud: ClaudeDesktopCloudOn, Account: ClaudeDesktopAccountSignedIn, Plan: "free"}, nil+ },+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ _ = p.Close(ctx)+ })++ type messageResponse struct {+ status int+ body string+ }+ response := make(chan messageResponse, 1)+ requestErr := make(chan error, 1)+ go func() {+ resp, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"claude-fable-5","messages":[]}`),+ )+ if err != nil {+ requestErr <- err+ return+ }+ defer resp.Body.Close()+ body, err := io.ReadAll(resp.Body)+ if err != nil {+ requestErr <- err+ return+ }+ response <- messageResponse{status: resp.StatusCode, body: string(body)}+ }()+ <-started+ if err := p.SetModels(updated); err != nil {+ t.Fatal(err)+ }+ close(release)+ select {+ case err := <-requestErr:+ t.Fatal(err)+ case resp := <-response:+ if resp.status != http.StatusBadRequest || !strings.Contains(resp.body, "model catalog changed") {+ t.Fatalf("response = (%d, %q), want status %d containing %q", resp.status, resp.body, http.StatusBadRequest, "model catalog changed")+ }+ case <-time.After(2 * time.Second):+ t.Fatal("timed out waiting for request")+ }+ if got := upstreamCalls.Load(); got != 0 {+ t.Fatalf("upstream calls = %d, want 0 after a slot change", got)+ }+}++func TestGatewayRejectsAdmittedRequestAfterSlotReassignment(t *testing.T) {+ for _, tt := range []struct {+ name string+ initial []ClaudeDesktopModel+ updated []ClaudeDesktopModel+ }{+ {+ name: "cloud",+ initial: ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "cloud-a:cloud", RequiredPlan: "free"}}),+ updated: ClaudeDesktopModelsFromRecommendations([]api.ModelRecommendation{{Model: "cloud-b:cloud", RequiredPlan: "free"}}),+ },+ {+ name: "local",+ initial: SelectClaudeDesktopModels(nil, []string{"local-a"}),+ updated: SelectClaudeDesktopModels(nil, []string{"local-b"}),+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: "http://127.0.0.1:11434",+ Model: tt.initial[0].OllamaModel,+ Models: tt.initial,+ })+ if err != nil {+ t.Fatal(err)+ }+ generation, admitted := p.modelSnapshotWithGeneration()+ if err := p.SetModels(tt.updated); err != nil {+ t.Fatal(err)+ }+ request := httptest.NewRequest(+ http.MethodPost,+ "http://127.0.0.1/v1/messages",+ strings.NewReader(`{"model":"claude-fable-5","messages":[]}`),+ )+ err = p.routeModel(request, generation, admitted)+ if err == nil || !strings.Contains(err.Error(), "model catalog changed") {+ t.Fatalf("route error = %v, want catalog-changed rejection", err)+ }+ })+ }+}++func TestGatewayLocalRequestSkipsAccountResolution(t *testing.T) {+ var accessCalls atomic.Int32+ var refreshCalls atomic.Int32+ upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ _, _ = io.WriteString(w, `{"ok":true}`)+ }))+ defer upstream.Close()+ models := SelectClaudeDesktopModels(nil, []string{"qwen3:8b"})+ p, err := NewClaudeDesktop(ClaudeDesktopConfig{+ ListenAddr: "127.0.0.1:0",+ OllamaURL: upstream.URL,+ Model: models[0].OllamaModel,+ Models: models,+ RefreshModels: func(context.Context, []ClaudeDesktopModel) ([]ClaudeDesktopModel, error) {+ refreshCalls.Add(1)+ return models, nil+ },+ ResolveAccessState: func(context.Context) (ClaudeDesktopAccessState, error) {+ accessCalls.Add(1)+ return ClaudeDesktopAccessState{}, errors.New("offline")+ },+ ListLocalModels: func(context.Context) ([]string, error) {+ return []string{"qwen3:8b"}, nil+ },+ })+ if err != nil {+ t.Fatal(err)+ }+ if err := p.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ _ = p.Close(ctx)+ })+ discovery, err := http.Get("http://" + p.Addr() + "/v1/models")+ if err != nil {+ t.Fatal(err)+ }+ assertResponseContains(t, discovery, http.StatusOK, "qwen3:8b")++ resp, err := http.Post(+ "http://"+p.Addr()+"/v1/messages",+ "application/json",+ strings.NewReader(`{"model":"claude-fable-5","messages":[]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ assertResponseContains(t, resp, http.StatusOK, `"ok":true`)+ if got := accessCalls.Load(); got != 0 {+ t.Fatalf("account resolution calls = %d, want 0 for a local model", got)+ }+ if got := refreshCalls.Load(); got != 0 {+ t.Fatalf("recommendation refresh calls = %d, want 0 for an all-local catalog", got)}}@@ -231,7 +794,7 @@ func TestGatewayCountsTokensLocally(t *testing.T) {resp, err := http.Post("http://"+p.Addr()+"/v1/messages/count_tokens","application/json",- strings.NewReader(`{"model":"claude-sonnet","messages":[{"role":"user","content":"hello world"}]}`),+ strings.NewReader(`{"model":"glm-5.2:cloud","messages":[{"role":"user","content":"hello world"}]}`),)if err != nil {t.Fatal(err)@@ -254,6 +817,37 @@ func TestGatewayCountsTokensLocally(t *testing.T) {}}+func TestGatewayRejectsUnknownModelRequests(t *testing.T) {+ var upstreamCalls atomic.Int32+ upstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {+ upstreamCalls.Add(1)+ }))+ defer upstream.Close()+ p := startTestGateway(t, upstream.URL)++ for _, path := range []string{"/v1/messages", "/v1/messages/count_tokens"} {+ resp, err := http.Post(+ "http://"+p.Addr()+path,+ "application/json",+ strings.NewReader(`{"model":"claude-stale","messages":[]}`),+ )+ if err != nil {+ t.Fatal(err)+ }+ body, err := io.ReadAll(resp.Body)+ _ = resp.Body.Close()+ if err != nil {+ t.Fatal(err)+ }+ if resp.StatusCode != http.StatusBadRequest || !strings.Contains(string(body), "unknown Claude model") {+ t.Fatalf("%s status/body = %d/%q", path, resp.StatusCode, body)+ }+ }+ if got := upstreamCalls.Load(); got != 0 {+ t.Fatalf("upstream calls = %d, want 0", got)+ }+}+func TestGatewayRejectsNonLoopbackHost(t *testing.T) {var upstreamCalls atomic.Int32upstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {@@ -396,24 +990,19 @@ func TestGatewayLazilyRetriesUnsupportedVision(t *testing.T) {}{{name: "message image",- body: `{"model":"claude-sonnet-5","messages":[{"role":"user","content":[{"type":"text","text":"Describe this"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}],"stream":true}`,+ body: `{"model":"deepseek-v4-pro:cloud","messages":[{"role":"user","content":[{"type":"text","text":"Describe this"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}],"stream":true}`,preserve: "Describe this",},{name: "tool result image",- body: `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"tool_result","tool_use_id":"tool_1","content":[{"type":"text","text":"Screenshot"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}]}`,+ body: `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"tool_result","tool_use_id":"tool_1","content":[{"type":"text","text":"Screenshot"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}]}`,preserve: "tool_1",},{name: "historical image with later text",- body: `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}},{"type":"text","text":"what dis"}]},{"role":"assistant","content":[{"type":"text","text":"I cannot inspect it"}]},{"role":"user","content":[{"type":"text","text":"kk"}]}]}`,+ body: `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}},{"type":"text","text":"what dis"}]},{"role":"assistant","content":[{"type":"text","text":"I cannot inspect it"}]},{"role":"user","content":[{"type":"text","text":"kk"}]}]}`,preserve: "kk",},- {- name: "unknown ID uses non-vision fallback",- body: `{"model":"claude-unknown","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`,- preserve: unsupportedImageNotice,- },} {t.Run(test.name, func(t *testing.T) {var upstreamBodies [][]byte@@ -472,7 +1061,7 @@ func TestGatewayDoesNotSanitizeImagesOnSuccessfulRequest(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}},{"type":"text","text":"what dis"}]}]}`+ body := `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}},{"type":"text","text":"what dis"}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -500,7 +1089,7 @@ func TestGatewayDoesNotRetryImageFreeBadRequest(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}]}`+ body := `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -525,7 +1114,7 @@ func TestGatewayDoesNotRetryUnrelatedBadRequestWithImage(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`+ body := `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -553,7 +1142,7 @@ func TestGatewayDoesNotRetryUnstructuredImageError(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-fable-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`+ body := `{"model":"glm-5.2:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -571,18 +1160,10 @@ func TestGatewayDoesNotRetryUnstructuredImageError(t *testing.T) {}}-func TestGatewayLogsUnknownModelFallback(t *testing.T) {- var logs bytes.Buffer- p := &ClaudeDesktop{- logger: slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug})),- }-- model := p.modelForClaudeID("claude-future", "kimi-k3:cloud")- if model.OllamaModel != "kimi-k3:cloud" {- t.Fatalf("fallback model = %q", model.OllamaModel)- }- if output := logs.String(); !strings.Contains(output, "requested_model=claude-future") || !strings.Contains(output, "default_model=kimi-k3:cloud") {- t.Fatalf("fallback log = %q", output)+func TestGatewayRejectsUnknownModel(t *testing.T) {+ p := &ClaudeDesktop{models: DefaultClaudeDesktopModels()}+ if _, err := p.modelForClaudeID("claude-future"); err == nil || !strings.Contains(err.Error(), "unknown Claude model") {+ t.Fatalf("error = %v, want unknown Claude model", err)}}@@ -610,7 +1191,7 @@ func TestGatewayAllowsVisionForSupportedModel(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-opus-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`+ body := `{"model":"kimi-k3:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -638,7 +1219,7 @@ func TestGatewayDoesNotRetryVisionModelBadRequest(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-opus-5","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`+ body := `{"model":"kimi-k3:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -660,7 +1241,7 @@ func TestGatewayCountsUnsupportedVisionWithoutUpstream(t *testing.T) {defer upstream.Close()p := startTestGateway(t, upstream.URL)- body := `{"model":"claude-haiku-4-5-20251001","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`+ body := `{"model":"deepseek-v4-flash:0731:cloud","messages":[{"role":"user","content":[{"type":"image","source":{"type":"base64","media_type":"image/png","data":"aW1hZ2U="}}]}]}`resp, err := http.Post("http://"+p.Addr()+"/v1/messages/count_tokens", "application/json", strings.NewReader(body))if err != nil {t.Fatal(err)@@ -698,7 +1279,7 @@ func TestGatewayWaitsForColdUpstream(t *testing.T) {resp, err := http.Post("http://"+p.Addr()+"/v1/messages","application/json",- strings.NewReader(`{"model":"claude-sonnet-5","messages":[]}`),+ strings.NewReader(`{"model":"deepseek-v4-pro:cloud","messages":[]}`),)if err != nil {errs <- err