Skip to content

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.go
index 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.AuthorizationError
if 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 = nil
claudeProxyFail = 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 := claudeAppProxy
claudeProxyMu.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 := claudeAppProxy
claudeAppProxy = nil
diff --git a/app/cmd/app/app_darwin.h b/app/cmd/app/app_darwin.h
index 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 ClaudeInstallResult
ClaudeInstallFailed,
};
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.m
index 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:configuration
delegate:self
delegateQueue:[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 = [NSError
errorWithDomain:@"com.ollama.app"
code:4
userInfo:@{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.go
index 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 string
cloudStatus 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 := false
if 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 string
const (
@@ -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.go
index 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 '', -- deprecated
auto_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 = 18
default:
// 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 bug
func (db *database) cleanupOrphanedData() error {
_, err := db.conn.Exec(`
@@ -1212,9 +1234,9 @@ func (db *database) getSettings() (Settings, error) {
var s Settings
err := 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_used
FROM 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.go
index 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.go
index 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 downloaded
AutoUpdateEnabled 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.go
index 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 testing
func 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.ts
index 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.ts
index 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.ts
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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 &amp; 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.tsx
index 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>
<p
id="claude-connected-description"
className="mt-2 text-[13px] leading-5 text-neutral-500"
>
- Choose an Ollama model from Claude&apos;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">
<button
diff --git a/app/ui/app/src/components/Settings.tsx b/app/ui/app/src/components/Settings.tsx
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.go
index 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.Settings
OnboardingVersion *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.go
index 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 string
Command string
}, len(got))
for _, item := range got {
byID[item.ID] = struct {
Installed *bool
+ Action string
Command 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.Value
ts := 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.go
index 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, forceChooser
cfg["inferenceGatewayBaseUrl"] = baseURL
cfg["inferenceGatewayApiKey"] = apiKey
cfg["inferenceGatewayAuthScheme"] = "bearer"
+ cfg["deploymentDisplayName"] = claudeDesktopProfileName
cfg["chatTabEnabled"] = true
delete(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 claudeDesktopThirdPartyPath
if 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 false
diff --git a/cmd/launch/claude_desktop_test.go b/cmd/launch/claude_desktop_test.go
index 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.go
index 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.Once
readyMu sync.Mutex
readyUntil time.Time
@@ -179,16 +129,22 @@ func NewClaudeDesktop(config ClaudeDesktopConfig) (*ClaudeDesktop, error) {
proxy.Transport = transport
proxy.FlushInterval = -1
p := &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)
return
case "/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)
return
case "/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 ClaudeDesktopAccessState
var 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.OllamaModel
w.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.OllamaModel
if 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.Round
if 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 15ae385a4..7086758bd 100644
--- a/internal/proxy/claude_desktop_test.go
+++ b/internal/proxy/claude_desktop_test.go
@@ -1,12 +1,10 @@
package proxy
import (
- "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.ID
gotNames[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.Bool
var 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.Int32
upstream := 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