ollama source for Momentry Core verification

app/.gitignore

@@ -0,0 +1,11 @@
+ollama.syso
+*.crt
+*.exe
+/app/app
+/app/squirrel
+ollama
+*cover*
+.vscode
+.env
+.DS_Store
+.claude

app/README.md

@@ -0,0 +1,97 @@
+# Ollama for macOS and Windows
+
+## Download
+
+- [macOS](https://github.com/ollama/app/releases/download/latest/Ollama.dmg)
+- [Windows](https://github.com/ollama/app/releases/download/latest/OllamaSetup.exe)
+
+## Development
+
+### Desktop App
+
+```bash
+go generate ./... &&
+go run ./cmd/app
+```
+
+### UI Development
+
+#### Setup
+
+Install required tools:
+
+```bash
+go install github.com/tkrajina/typescriptify-golang-structs/tscriptify@latest
+```
+
+#### Develop UI (Development Mode)
+
+1. Start the React development server (with hot-reload):
+
+```bash
+cd ui/app
+npm install
+npm run dev
+```
+
+2. In a separate terminal, run the Ollama app with the `-dev` flag:
+
+```bash
+go generate ./... &&
+OLLAMA_DEBUG=1 go run ./cmd/app -dev
+```
+
+The `-dev` flag enables:
+
+- Loading the UI from the Vite dev server at http://localhost:5173
+- Fixed UI server port at http://127.0.0.1:3001 for API requests
+- CORS headers for cross-origin requests
+- Hot-reload support for UI development
+
+## Build
+
+
+### Windows
+
+- https://jrsoftware.org/isinfo.php
+
+
+**Dependencies** - either build a local copy of ollama, or use a github release
+```powershell
+# Local dependencies
+.\scripts\deps_local.ps1
+
+# Release dependencies
+.\scripts\deps_release.ps1 0.6.8
+```
+
+**Build**
+```powershell
+.\scripts\build_windows.ps1
+```
+
+### macOS
+
+CI builds with Xcode 14.1 for OS compatibility prior to v13.  If you want to manually build v11+ support, you can download the older Xcode [here](https://developer.apple.com/services-account/download?path=/Developer_Tools/Xcode_14.1/Xcode_14.1.xip), extract, then `mv ./Xcode.app /Applications/Xcode_14.1.0.app` then activate with:
+
+```
+export CGO_CFLAGS="-O3 -mmacosx-version-min=12.0"
+export CGO_CXXFLAGS="-O3 -mmacosx-version-min=12.0"
+export CGO_LDFLAGS="-mmacosx-version-min=12.0"
+export SDKROOT=/Applications/Xcode_14.1.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
+export DEVELOPER_DIR=/Applications/Xcode_14.1.0.app/Contents/Developer
+```
+
+**Dependencies** - either build a local copy of Ollama, or use a GitHub release:
+```sh
+# Local dependencies
+./scripts/deps_local.sh
+
+# Release dependencies
+./scripts/deps_release.sh 0.6.8
+```
+
+**Build**
+```sh
+./scripts/build_darwin.sh
+```

app/assets/assets.go

@@ -0,0 +1,19 @@
+//go:build windows || darwin
+
+package assets
+
+import (
+	"embed"
+	"io/fs"
+)
+
+//go:embed *.ico
+var icons embed.FS
+
+func ListIcons() ([]string, error) {
+	return fs.Glob(icons, "*")
+}
+
+func GetIcon(filename string) ([]byte, error) {
+	return icons.ReadFile(filename)
+}

app/auth/connect.go

@@ -0,0 +1,26 @@
+//go:build windows || darwin
+
+package auth
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"os"
+
+	"github.com/ollama/ollama/auth"
+)
+
+// BuildConnectURL generates the connect URL with the public key and device name
+func BuildConnectURL(baseURL string) (string, error) {
+	pubKey, err := auth.GetPublicKey()
+	if err != nil {
+		return "", fmt.Errorf("failed to get public key: %w", err)
+	}
+
+	encodedKey := base64.RawURLEncoding.EncodeToString([]byte(pubKey))
+	hostname, _ := os.Hostname()
+	encodedDevice := url.QueryEscape(hostname)
+
+	return fmt.Sprintf("%s/connect?name=%s&key=%s&launch=true", baseURL, encodedDevice, encodedKey), nil
+}

app/cmd/app/AppDelegate.h

@@ -0,0 +1,7 @@
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+
+@end

app/cmd/app/app.go

@@ -0,0 +1,507 @@
+//go:build windows || darwin
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/ollama/ollama/app/auth"
+	"github.com/ollama/ollama/app/logrotate"
+	"github.com/ollama/ollama/app/server"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/tools"
+	"github.com/ollama/ollama/app/ui"
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var (
+	wv           = &Webview{}
+	uiServerPort int
+	appStore     *store.Store
+)
+
+var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
+
+var (
+	fastStartup = false
+	devMode     = false
+)
+
+type appMove int
+
+const (
+	CannotMove appMove = iota
+	UserDeclinedMove
+	MoveCompleted
+	AlreadyMoved
+	LoginSession
+	PermissionDenied
+	MoveError
+)
+
+func main() {
+	startHidden := false
+	var urlSchemeRequest string
+	if len(os.Args) > 1 {
+		for _, arg := range os.Args {
+			// Handle URL scheme requests (Windows)
+			if strings.HasPrefix(arg, "ollama://") {
+				urlSchemeRequest = arg
+				slog.Info("received URL scheme request", "url", arg)
+				continue
+			}
+			switch arg {
+			case "serve":
+				fmt.Fprintln(os.Stderr, "serve command not supported, use ollama")
+				os.Exit(1)
+			case "version", "-v", "--version":
+				fmt.Println(version.Version)
+				os.Exit(0)
+			case "background":
+				// When running the process in this "background" mode, we spawn a
+				// child process for the main app.  This is necessary so the
+				// "Allow in the Background" setting in MacOS can be unchecked
+				// without breaking the main app.  Two copies of the app are
+				// present in the bundle, one for the main app and one for the
+				// background initiator.
+				fmt.Fprintln(os.Stdout, "starting in background")
+				runInBackground()
+				os.Exit(0)
+			case "hidden", "-j", "--hide":
+				// startHidden suppresses the UI on startup, and can be triggered multiple ways
+				// On windows, path based via login startup detection
+				// On MacOS via [NSApp isHidden] from `open -j -a /Applications/Ollama.app` or equivalent
+				// On both via the "hidden" command line argument
+				startHidden = true
+			case "--fast-startup":
+				// Skip optional steps like pending updates to start quickly for immediate use
+				fastStartup = true
+			case "-dev", "--dev":
+				// Development mode: use local dev server and enable CORS
+				devMode = true
+			}
+		}
+	}
+
+	level := slog.LevelInfo
+	if debug {
+		level = slog.LevelDebug
+	}
+
+	logrotate.Rotate(appLogPath)
+	if _, err := os.Stat(filepath.Dir(appLogPath)); errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(filepath.Dir(appLogPath), 0o755); err != nil {
+			slog.Error(fmt.Sprintf("failed to create server log dir %v", err))
+			return
+		}
+	}
+
+	var logFile io.Writer
+	var err error
+	logFile, err = os.OpenFile(appLogPath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o755)
+	if err != nil {
+		slog.Error(fmt.Sprintf("failed to create server log %v", err))
+		return
+	}
+	// Detect if we're a GUI app on windows, and if not, send logs to console as well
+	if os.Stderr.Fd() != 0 {
+		// Console app detected
+		logFile = io.MultiWriter(os.Stderr, logFile)
+	}
+
+	handler := slog.NewTextHandler(logFile, &slog.HandlerOptions{
+		Level:     level,
+		AddSource: true,
+		ReplaceAttr: func(_ []string, attr slog.Attr) slog.Attr {
+			if attr.Key == slog.SourceKey {
+				source := attr.Value.Any().(*slog.Source)
+				source.File = filepath.Base(source.File)
+			}
+			return attr
+		},
+	})
+
+	slog.SetDefault(slog.New(handler))
+	logStartup()
+
+	// On Windows, check if another instance is running and send URL to it
+	// Do this after logging is set up so we can debug issues
+	if runtime.GOOS == "windows" && urlSchemeRequest != "" {
+		slog.Debug("checking for existing instance", "url", urlSchemeRequest)
+		if checkAndHandleExistingInstance(urlSchemeRequest) {
+			// The function will exit if it successfully sends to another instance
+			// If we reach here, we're the first/only instance
+		} else {
+			// No existing instance found, handle the URL scheme in this instance
+			go func() {
+				handleURLSchemeInCurrentInstance(urlSchemeRequest)
+			}()
+		}
+	}
+
+	// Detect if this is a first start after an upgrade, in
+	// which case we need to do some cleanup
+	var skipMove bool
+	if _, err := os.Stat(updater.UpgradeMarkerFile); err == nil {
+		slog.Debug("first start after upgrade")
+		err = updater.DoPostUpgradeCleanup()
+		if err != nil {
+			slog.Error("failed to cleanup prior version", "error", err)
+		}
+		// We never prompt to move the app after an upgrade
+		skipMove = true
+		// Start hidden after updates to prevent UI from opening automatically
+		startHidden = true
+	}
+
+	if !skipMove && !fastStartup {
+		if maybeMoveAndRestart() == MoveCompleted {
+			return
+		}
+	}
+
+	// Check if another instance is already running
+	// On Windows, focus the existing instance; on other platforms, kill it
+	handleExistingInstance(startHidden)
+
+	// on macOS, offer the user to create a symlink
+	// from /usr/local/bin/ollama to the app bundle
+	installSymlink()
+
+	var ln net.Listener
+	if devMode {
+		// Use a fixed port in dev mode for predictable API access
+		ln, err = net.Listen("tcp", "127.0.0.1:3001")
+	} else {
+		ln, err = net.Listen("tcp", "127.0.0.1:0")
+	}
+	if err != nil {
+		slog.Error("failed to find available port", "error", err)
+		return
+	}
+
+	port := ln.Addr().(*net.TCPAddr).Port
+	token := uuid.NewString()
+	wv.port = port
+	wv.token = token
+	uiServerPort = port
+
+	st := &store.Store{}
+	appStore = st
+
+	// Enable CORS in development mode
+	if devMode {
+		os.Setenv("OLLAMA_CORS", "1")
+
+		// Check if Vite dev server is running on port 5173
+		var conn net.Conn
+		var err error
+		for _, addr := range []string{"127.0.0.1:5173", "localhost:5173"} {
+			conn, err = net.DialTimeout("tcp", addr, 2*time.Second)
+			if err == nil {
+				conn.Close()
+				break
+			}
+		}
+
+		if err != nil {
+			slog.Error("Vite dev server not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Error: Vite dev server is not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Please run 'npm run dev' in the ui/app directory to start the UI in development mode")
+			os.Exit(1)
+		}
+	}
+
+	// Initialize tools registry
+	toolRegistry := tools.NewRegistry()
+	slog.Info("initialized tools registry", "tool_count", len(toolRegistry.List()))
+
+	// ctx is the app-level context that will be used to stop the app
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// octx is the ollama server context that will be used to stop the ollama server
+	octx, ocancel := context.WithCancel(ctx)
+
+	// TODO (jmorganca): instead we should instantiate the
+	// webview with the store instead of assigning it here, however
+	// making the webview a global variable is easier for now
+	wv.Store = st
+	done := make(chan error, 1)
+	osrv := server.New(st, devMode)
+	go func() {
+		slog.Info("starting ollama server")
+		done <- osrv.Run(octx)
+	}()
+
+	upd := &updater.Updater{Store: st}
+
+	uiServer := ui.Server{
+		Token: token,
+		Restart: func() {
+			ocancel()
+			<-done
+			octx, ocancel = context.WithCancel(ctx)
+			go func() {
+				done <- osrv.Run(octx)
+			}()
+		},
+		Store:        st,
+		ToolRegistry: toolRegistry,
+		Dev:          devMode,
+		Logger:       slog.Default(),
+		Updater:      upd,
+		UpdateAvailableFunc: func() {
+			UpdateAvailable("")
+		},
+	}
+
+	srv := &http.Server{
+		Handler: uiServer.Handler(),
+	}
+
+	// Start the UI server
+	slog.Info("starting ui server", "port", port)
+	go func() {
+		slog.Debug("starting ui server on port", "port", port)
+		err = srv.Serve(ln)
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			slog.Warn("desktop server", "error", err)
+		}
+		slog.Debug("background desktop server done")
+	}()
+
+	upd.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
+
+	// Check for pending updates on startup (show tray notification if update is ready)
+	if updater.IsUpdatePending() {
+		// On Windows, the tray is initialized in osRun(). Calling UpdateAvailable
+		// before that would dereference a nil tray callback.
+		// TODO: refactor so the update check runs after platform init on all platforms.
+		if runtime.GOOS == "windows" {
+			slog.Debug("update pending on startup, deferring tray notification until tray initialization")
+		} else {
+			slog.Debug("update pending on startup, showing tray notification")
+			UpdateAvailable("")
+		}
+	}
+
+	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
+	if err != nil {
+		slog.Error("failed to load has completed first run", "error", err)
+	}
+
+	if !hasCompletedFirstRun {
+		err = st.SetHasCompletedFirstRun(true)
+		if err != nil {
+			slog.Error("failed to set has completed first run", "error", err)
+		}
+	}
+
+	// capture SIGINT and SIGTERM signals and gracefully shutdown the app
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-signals
+		slog.Info("received SIGINT or SIGTERM signal, shutting down")
+		quit()
+	}()
+
+	if urlSchemeRequest != "" {
+		go func() {
+			handleURLSchemeInCurrentInstance(urlSchemeRequest)
+		}()
+	} else {
+		slog.Debug("no URL scheme request to handle")
+	}
+
+	go func() {
+		slog.Debug("waiting for ollama server to be ready")
+		if err := ui.WaitForServer(ctx, 10*time.Second); err != nil {
+			slog.Warn("ollama server not ready, continuing anyway", "error", err)
+		}
+
+		if _, err := uiServer.UserData(ctx); err != nil {
+			slog.Warn("failed to load user data", "error", err)
+		}
+	}()
+
+	osRun(cancel, hasCompletedFirstRun, startHidden)
+
+	slog.Info("shutting down desktop server")
+	if err := srv.Close(); err != nil {
+		slog.Warn("error shutting down desktop server", "error", err)
+	}
+
+	slog.Info("shutting down ollama server")
+	cancel()
+	<-done
+}
+
+func startHiddenTasks() {
+	// If an upgrade is ready and we're in hidden mode, perform it at startup.
+	// If we're not in hidden mode, we want to start as fast as possible and not
+	// slow the user down with an upgrade.
+	if updater.IsUpdatePending() {
+		if fastStartup {
+			// CLI triggered app startup use-case
+			slog.Info("deferring pending update for fast startup")
+		} else {
+			// Check if auto-update is enabled before automatically upgrading
+			settings, err := appStore.Settings()
+			if err != nil {
+				slog.Warn("failed to load settings for upgrade check", "error", err)
+			} else if !settings.AutoUpdateEnabled {
+				slog.Info("auto-update disabled, skipping automatic upgrade at startup")
+				// Still show tray notification so user knows update is ready
+				UpdateAvailable("")
+				return
+			}
+
+			if err := updater.DoUpgradeAtStartup(); err != nil {
+				slog.Info("unable to perform upgrade at startup", "error", err)
+				// Make sure the restart to upgrade menu shows so we can attempt an interactive upgrade to get authorization
+				UpdateAvailable("")
+			} else {
+				slog.Debug("launching new version...")
+				// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+				LaunchNewApp()
+				os.Exit(0)
+			}
+		}
+	}
+}
+
+func checkUserLoggedIn(uiServerPort int) bool {
+	if uiServerPort == 0 {
+		slog.Debug("UI server not ready yet, skipping auth check")
+		return false
+	}
+
+	resp, err := http.Post(fmt.Sprintf("http://127.0.0.1:%d/api/me", uiServerPort), "application/json", nil)
+	if err != nil {
+		slog.Debug("failed to call local auth endpoint", "error", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	// Check if the response is successful
+	if resp.StatusCode != http.StatusOK {
+		slog.Debug("auth endpoint returned non-OK status", "status", resp.StatusCode)
+		return false
+	}
+
+	var user struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+		slog.Debug("failed to parse user response", "error", err)
+		return false
+	}
+
+	// Verify we have a valid user with an ID and name
+	if user.ID == "" || user.Name == "" {
+		slog.Debug("user response missing required fields", "id", user.ID, "name", user.Name)
+		return false
+	}
+
+	slog.Debug("user is logged in", "user_id", user.ID, "user_name", user.Name)
+	return true
+}
+
+// handleConnectURLScheme fetches the connect URL and opens it in the browser
+func handleConnectURLScheme() {
+	if checkUserLoggedIn(uiServerPort) {
+		slog.Info("user is already logged in, opening app instead")
+		showWindow(wv.webview.Window())
+		return
+	}
+
+	connectURL, err := auth.BuildConnectURL("https://ollama.com")
+	if err != nil {
+		slog.Error("failed to build connect URL", "error", err)
+		openInBrowser("https://ollama.com/connect")
+		return
+	}
+
+	openInBrowser(connectURL)
+}
+
+// openInBrowser opens the specified URL in the default browser
+func openInBrowser(url string) {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "rundll32"
+		args = []string{"url.dll,FileProtocolHandler", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"... should not reach here
+		slog.Warn("unsupported OS for openInBrowser", "os", runtime.GOOS)
+	}
+
+	slog.Info("executing browser command", "cmd", cmd, "args", args)
+	if err := exec.Command(cmd, args...).Start(); err != nil {
+		slog.Error("failed to open URL in browser", "url", url, "cmd", cmd, "args", args, "error", err)
+	}
+}
+
+// parseURLScheme parses an ollama:// URL and validates it
+// Supports: ollama:// (open app) and ollama://connect (OAuth)
+func parseURLScheme(urlSchemeRequest string) (isConnect bool, err error) {
+	parsedURL, err := url.Parse(urlSchemeRequest)
+	if err != nil {
+		return false, fmt.Errorf("invalid URL: %w", err)
+	}
+
+	// Check if this is a connect URL
+	if parsedURL.Host == "connect" || strings.TrimPrefix(parsedURL.Path, "/") == "connect" {
+		return true, nil
+	}
+
+	// Allow bare ollama:// or ollama:/// to open the app
+	if (parsedURL.Host == "" && parsedURL.Path == "") || parsedURL.Path == "/" {
+		return false, nil
+	}
+
+	return false, fmt.Errorf("unsupported ollama:// URL path: %s", urlSchemeRequest)
+}
+
+// handleURLSchemeInCurrentInstance processes URL scheme requests in the current instance
+func handleURLSchemeInCurrentInstance(urlSchemeRequest string) {
+	isConnect, err := parseURLScheme(urlSchemeRequest)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		if wv.webview != nil {
+			showWindow(wv.webview.Window())
+		}
+	}
+}

app/cmd/app/app_darwin.go

@@ -0,0 +1,262 @@
+//go:build windows || darwin
+
+package main
+
+// #cgo CFLAGS: -x objective-c
+// #cgo LDFLAGS: -framework Webkit -framework Cocoa -framework LocalAuthentication -framework ServiceManagement
+// #include "app_darwin.h"
+// #include "../../updater/updater_darwin.h"
+// typedef const char cchar_t;
+import "C"
+
+import (
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var ollamaPath = func() string {
+	if updater.BundlePath != "" {
+		return filepath.Join(updater.BundlePath, "Contents", "Resources", "ollama")
+	}
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		slog.Warn("failed to get pwd", "error", err)
+		return ""
+	}
+	return filepath.Join(pwd, "ollama")
+}()
+
+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")
+)
+
+// TODO(jmorganca): pre-create the window and pass
+// it to the webview instead of using the internal one
+//
+//export StartUI
+func StartUI(path *C.cchar_t) {
+	p := C.GoString(path)
+	wv.Run(p)
+	styleWindow(wv.webview.Window())
+	C.setWindowDelegate(wv.webview.Window())
+}
+
+//export ShowUI
+func ShowUI() {
+	// If webview is already running, just show the window
+	if wv.IsRunning() && wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		root := C.CString("/")
+		defer C.free(unsafe.Pointer(root))
+		StartUI(root)
+	}
+}
+
+//export StopUI
+func StopUI() {
+	wv.Terminate()
+}
+
+//export StartUpdate
+func StartUpdate() {
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Error("upgrade failed", "error", err)
+		return
+	}
+	slog.Debug("launching new version...")
+	// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+	LaunchNewApp()
+	// not reached if upgrade works, the new app will kill this process
+}
+
+//export darwinStartHiddenTasks
+func darwinStartHiddenTasks() {
+	startHiddenTasks()
+}
+
+func init() {
+	// Temporary code to mimic Squirrel ShipIt behavior
+	if len(os.Args) > 2 {
+		if os.Args[1] == "___launch___" {
+			path := strings.TrimPrefix(os.Args[2], "file://")
+			slog.Info("Ollama binary called as ShipIt - launching", "app", path)
+			appName := C.CString(path)
+			defer C.free(unsafe.Pointer(appName))
+			C.launchApp(appName)
+			slog.Info("other instance has been launched")
+			time.Sleep(5 * time.Second)
+			slog.Info("exiting with zero status")
+			os.Exit(0)
+		}
+	}
+}
+
+// maybeMoveAndRestart checks if we should relocate
+// and returns true if we did and should immediately exit
+func maybeMoveAndRestart() appMove {
+	if updater.BundlePath == "" {
+		// Typically developer mode with 'go run ./cmd/app'
+		return CannotMove
+	}
+	// Respect users intent if they chose "keep" vs. "replace" when dragging to Applications
+	if strings.HasPrefix(updater.BundlePath, strings.TrimSuffix(updater.SystemWidePath, filepath.Ext(updater.SystemWidePath))) {
+		return AlreadyMoved
+	}
+
+	// Ask to move to applications directory
+	status := (appMove)(C.askToMoveToApplications())
+	if status == MoveCompleted {
+		// Double check
+		if _, err := os.Stat(updater.SystemWidePath); err != nil {
+			slog.Warn("stat failure after move", "path", updater.SystemWidePath, "error", err)
+			return MoveError
+		}
+	}
+	return status
+}
+
+// handleExistingInstance handles existing instances on macOS
+func handleExistingInstance(_ bool) {
+	C.killOtherInstances()
+}
+
+func installSymlink() {
+	if !isApp {
+		return
+	}
+	cliPath := C.CString(ollamaPath)
+	defer C.free(unsafe.Pointer(cliPath))
+
+	// Check the users path first
+	cmd, _ := exec.LookPath("ollama")
+	if cmd != "" {
+		resolved, err := os.Readlink(cmd)
+		if err == nil {
+			tmp, err := filepath.Abs(resolved)
+			if err == nil {
+				resolved = tmp
+			}
+		} else {
+			resolved = cmd
+		}
+		if resolved == ollamaPath {
+			slog.Info("ollama already in users PATH", "cli", cmd)
+			return
+		}
+	}
+
+	code := C.installSymlink(cliPath)
+	if code != 0 {
+		slog.Error("Failed to install symlink")
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	slog.Debug("update detected, adjusting menu")
+	// TODO (jmorganca): find a better check for development mode than checking the bundle path
+	if updater.BundlePath != "" {
+		C.updateAvailable()
+	}
+	return nil
+}
+
+func osRun(_ func(), hasCompletedFirstRun, startHidden bool) {
+	registerLaunchAgent(hasCompletedFirstRun)
+
+	// Run the native macOS app
+	// Note: this will block until the app is closed
+	slog.Debug("starting native darwin event loop")
+	C.run(C._Bool(hasCompletedFirstRun), C._Bool(startHidden))
+}
+
+func quit() {
+	C.quit()
+}
+
+func LaunchNewApp() {
+	appName := C.CString(updater.BundlePath)
+	defer C.free(unsafe.Pointer(appName))
+	C.launchApp(appName)
+}
+
+func registerLaunchAgent(hasCompletedFirstRun bool) {
+	// Remove any stale Login Item registrations
+	C.unregisterSelfFromLoginItem()
+
+	C.registerSelfAsLoginItem(C._Bool(hasCompletedFirstRun))
+}
+
+func logStartup() {
+	appPath := updater.BundlePath
+	if appPath == updater.SystemWidePath {
+		// Detect sandboxed scenario
+		exe, err := os.Executable()
+		if err == nil {
+			p := filepath.Dir(exe)
+			if filepath.Base(p) == "MacOS" {
+				p = filepath.Dir(filepath.Dir(p))
+				if p != appPath {
+					slog.Info("starting sandboxed Ollama", "app", appPath, "sandbox", p)
+					return
+				}
+			}
+		}
+	}
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+func hideWindow(ptr unsafe.Pointer) {
+	C.hideWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	C.showWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func styleWindow(ptr unsafe.Pointer) {
+	C.styleWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func runInBackground() {
+	cmd := exec.Command(filepath.Join(updater.BundlePath, "Contents", "MacOS", "Ollama"), "hidden")
+	if cmd != nil {
+		err := cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "bundlePath", updater.BundlePath, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama in background", "bundlePath", updater.BundlePath)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {
+	C.drag(C.uintptr_t(uintptr(ptr)))
+}
+
+func doubleClick(ptr unsafe.Pointer) {
+	C.doubleClick(C.uintptr_t(uintptr(ptr)))
+}
+
+//export handleConnectURL
+func handleConnectURL() {
+	handleConnectURLScheme()
+}
+
+// checkAndHandleExistingInstance is not needed on non-Windows platforms
+func checkAndHandleExistingInstance(_ string) bool {
+	return false
+}

app/cmd/app/app_darwin.h

@@ -0,0 +1,43 @@
+#import <Cocoa/Cocoa.h>
+#import <Security/Security.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+@end
+
+enum AppMove
+{
+    CannotMove,
+    UserDeclinedMove,
+    MoveCompleted,
+    AlreadyMoved,
+    LoginSession,
+    PermissionDenied,
+    MoveError,
+};
+
+void run(bool firstTimeRun, bool startHidden);
+void killOtherInstances();
+enum AppMove askToMoveToApplications();
+int createSymlinkWithAuthorization();
+int installSymlink(const char *cliPath);
+extern void Restart();
+// extern void Quit();
+void StartUI(const char *path);
+void ShowUI();
+void StopUI();
+void StartUpdate();
+void darwinStartHiddenTasks();
+void launchApp(const char *appPath);
+void updateAvailable();
+void quit();
+void uiRequest(char *path);
+void registerSelfAsLoginItem(bool firstTimeRun);
+void unregisterSelfFromLoginItem();
+void setWindowDelegate(void *window);
+void showWindow(uintptr_t wndPtr);
+void hideWindow(uintptr_t wndPtr);
+void styleWindow(uintptr_t wndPtr);
+void drag(uintptr_t wndPtr);
+void doubleClick(uintptr_t wndPtr);
+void handleConnectURL();

app/cmd/app/app_windows.go

@@ -0,0 +1,448 @@
+//go:build windows || darwin
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"log/slog"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+	"github.com/ollama/ollama/app/wintray"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	u32                  = windows.NewLazySystemDLL("User32.dll")
+	pBringWindowToTop    = u32.NewProc("BringWindowToTop")
+	pShowWindow          = u32.NewProc("ShowWindow")
+	pSendMessage         = u32.NewProc("SendMessageA")
+	pGetSystemMetrics    = u32.NewProc("GetSystemMetrics")
+	pGetWindowRect       = u32.NewProc("GetWindowRect")
+	pSetWindowPos        = u32.NewProc("SetWindowPos")
+	pSetForegroundWindow = u32.NewProc("SetForegroundWindow")
+	pSetActiveWindow     = u32.NewProc("SetActiveWindow")
+	pIsIconic            = u32.NewProc("IsIconic")
+
+	appPath         = filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", "Ollama")
+	appLogPath      = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "app.log")
+	startupShortcut = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "Ollama.lnk")
+	ollamaPath      string
+	DesktopAppName  = "ollama app.exe"
+)
+
+func init() {
+	// With alternate install location use executable location
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Warn("error discovering executable directory", "error", err)
+	} else {
+		appPath = filepath.Dir(exe)
+	}
+	ollamaPath = filepath.Join(appPath, "ollama.exe")
+
+	// Handle developer mode (go run ./cmd/app)
+	if _, err := os.Stat(ollamaPath); err != nil {
+		pwd, err := os.Getwd()
+		if err != nil {
+			slog.Warn("missing ollama.exe and failed to get pwd", "error", err)
+			return
+		}
+		distAppPath := filepath.Join(pwd, "dist", "windows-"+runtime.GOARCH)
+		distOllamaPath := filepath.Join(distAppPath, "ollama.exe")
+		if _, err := os.Stat(distOllamaPath); err == nil {
+			slog.Info("detected developer mode")
+			appPath = distAppPath
+			ollamaPath = distOllamaPath
+		}
+	}
+}
+
+func maybeMoveAndRestart() appMove {
+	return 0
+}
+
+// handleExistingInstance checks for existing instances and optionally focuses them
+func handleExistingInstance(startHidden bool) {
+	if wintray.CheckAndFocusExistingInstance(!startHidden) {
+		slog.Info("existing instance found, exiting")
+		os.Exit(0)
+	}
+}
+
+func installSymlink() {}
+
+type appCallbacks struct {
+	t        wintray.TrayCallbacks
+	shutdown func()
+}
+
+var app = &appCallbacks{}
+
+func (ac *appCallbacks) UIRun(path string) {
+	wv.Run(path)
+}
+
+func (*appCallbacks) UIShow() {
+	if wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		wv.Run("/")
+	}
+}
+
+func (*appCallbacks) UITerminate() {
+	wv.Terminate()
+}
+
+func (*appCallbacks) UIRunning() bool {
+	return wv.IsRunning()
+}
+
+func (app *appCallbacks) Quit() {
+	app.t.Quit()
+	wv.Terminate()
+}
+
+// TODO - reconcile with above for consistency between mac/windows
+func quit() {
+	wv.Terminate()
+}
+
+func (app *appCallbacks) DoUpdate() {
+	// Safeguard in case we have requests in flight that need to drain...
+	slog.Info("Waiting for server to shutdown")
+
+	app.shutdown()
+
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
+	}
+}
+
+// HandleURLScheme implements the URLSchemeHandler interface
+func (app *appCallbacks) HandleURLScheme(urlScheme string) {
+	handleURLSchemeRequest(urlScheme)
+}
+
+// handleURLSchemeRequest processes URL scheme requests from other instances
+func handleURLSchemeRequest(urlScheme string) {
+	isConnect, err := parseURLScheme(urlScheme)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlScheme, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		if wv.webview != nil {
+			showWindow(wv.webview.Window())
+		}
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	if app.t == nil {
+		slog.Debug("tray not yet initialized, skipping update notification")
+		return nil
+	}
+	return app.t.UpdateAvailable(ver)
+}
+
+func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
+	var err error
+	app.shutdown = shutdown
+	app.t, err = wintray.NewTray(app)
+	if err != nil {
+		log.Fatalf("Failed to start: %s", err)
+	}
+
+	// Check for pending updates now that the tray is initialized.
+	// The platform-independent check in app.go fires before osRun,
+	// when app.t is still nil, so we must re-check here.
+	if updater.IsUpdatePending() {
+		slog.Debug("update pending on startup, showing tray notification")
+		UpdateAvailable("")
+	}
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+
+	// TODO - can this be generalized?
+	go func() {
+		<-signals
+		slog.Debug("shutting down due to signal")
+		app.t.Quit()
+		wv.Terminate()
+	}()
+
+	// On windows, we run the final tasks in the main thread
+	// before starting the tray event loop.  These final tasks
+	// may trigger the UI, and must do that from the main thread.
+	if !startHidden {
+		// Determine if the process was started from a shortcut
+		// ~\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Ollama
+		const STARTF_TITLEISLINKNAME = 0x00000800
+		var info windows.StartupInfo
+		if err := windows.GetStartupInfo(&info); err != nil {
+			slog.Debug("unable to retrieve startup info", "error", err)
+		} else if info.Flags&STARTF_TITLEISLINKNAME == STARTF_TITLEISLINKNAME {
+			linkPath := windows.UTF16PtrToString(info.Title)
+			if strings.Contains(linkPath, "Startup") {
+				startHidden = true
+			}
+		}
+	}
+	if startHidden {
+		startHiddenTasks()
+	} else {
+		ptr := wv.Run("/")
+
+		// Set the window icon using the tray icon
+		if ptr != nil {
+			iconHandle := app.t.GetIconHandle()
+			if iconHandle != 0 {
+				hwnd := uintptr(ptr)
+				const ICON_SMALL = 0
+				const ICON_BIG = 1
+				const WM_SETICON = 0x0080
+
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+			}
+		}
+
+		centerWindow(ptr)
+	}
+
+	if !hasCompletedFirstRun {
+		// Only create the login shortcut on first start
+		// so we can respect users deletion of the link
+		err = createLoginShortcut()
+		if err != nil {
+			slog.Warn("unable to create login shortcut", "error", err)
+		}
+	}
+
+	app.t.TrayRun() // This will block the main thread
+}
+
+func createLoginShortcut() error {
+	// The installer lays down a shortcut for us so we can copy it without
+	// having to resort to calling COM APIs to establish the shortcut
+	shortcutOrigin := filepath.Join(appPath, "lib", "Ollama.lnk")
+
+	_, err := os.Stat(startupShortcut)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			in, err := os.Open(shortcutOrigin)
+			if err != nil {
+				return fmt.Errorf("unable to open shortcut %s : %w", shortcutOrigin, err)
+			}
+			defer in.Close()
+			out, err := os.Create(startupShortcut)
+			if err != nil {
+				return fmt.Errorf("unable to open startup link %s : %w", startupShortcut, err)
+			}
+			defer out.Close()
+			_, err = io.Copy(out, in)
+			if err != nil {
+				return fmt.Errorf("unable to copy shortcut %s : %w", startupShortcut, err)
+			}
+			err = out.Sync()
+			if err != nil {
+				return fmt.Errorf("unable to sync shortcut %s : %w", startupShortcut, err)
+			}
+			slog.Info("Created Startup shortcut", "shortcut", startupShortcut)
+		} else {
+			slog.Warn("unexpected error looking up Startup shortcut", "error", err)
+		}
+	} else {
+		slog.Debug("Startup link already exists", "shortcut", startupShortcut)
+	}
+	return nil
+}
+
+func LaunchNewApp() {
+}
+
+func logStartup() {
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+const (
+	SW_HIDE        = 0  // Hides the window
+	SW_SHOW        = 5  // Shows window in its current size/position
+	SW_SHOWNA      = 8  // Shows without activating
+	SW_MINIMIZE    = 6  // Minimizes the window
+	SW_RESTORE     = 9  // Restores to previous size/position
+	SW_SHOWDEFAULT = 10 // Sets show state based on program state
+	SM_CXSCREEN    = 0
+	SM_CYSCREEN    = 1
+	HWND_TOP       = 0
+	SWP_NOSIZE     = 0x0001
+	SWP_NOMOVE     = 0x0002
+	SWP_NOZORDER   = 0x0004
+	SWP_SHOWWINDOW = 0x0040
+
+	// Menu constants
+	MF_STRING     = 0x00000000
+	MF_SEPARATOR  = 0x00000800
+	MF_GRAYED     = 0x00000001
+	TPM_RETURNCMD = 0x0100
+)
+
+// POINT structure for cursor position
+type POINT struct {
+	X int32
+	Y int32
+}
+
+// Rect structure for GetWindowRect
+type Rect struct {
+	Left   int32
+	Top    int32
+	Right  int32
+	Bottom int32
+}
+
+func centerWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd == 0 {
+		return
+	}
+
+	var rect Rect
+	pGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&rect)))
+
+	screenWidth, _, _ := pGetSystemMetrics.Call(uintptr(SM_CXSCREEN))
+	screenHeight, _, _ := pGetSystemMetrics.Call(uintptr(SM_CYSCREEN))
+
+	windowWidth := rect.Right - rect.Left
+	windowHeight := rect.Bottom - rect.Top
+
+	x := (int32(screenWidth) - windowWidth) / 2
+	y := (int32(screenHeight) - windowHeight) / 2
+
+	// Ensure the window is not positioned off-screen
+	if x < 0 {
+		x = 0
+	}
+	if y < 0 {
+		y = 0
+	}
+
+	pSetWindowPos.Call(
+		hwnd,
+		uintptr(HWND_TOP),
+		uintptr(x),
+		uintptr(y),
+		uintptr(windowWidth),  // Keep original width
+		uintptr(windowHeight), // Keep original height
+		uintptr(SWP_SHOWWINDOW),
+	)
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		iconHandle := app.t.GetIconHandle()
+		if iconHandle != 0 {
+			const ICON_SMALL = 0
+			const ICON_BIG = 1
+			const WM_SETICON = 0x0080
+
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+		}
+
+		// Check if window is minimized
+		isMinimized, _, _ := pIsIconic.Call(hwnd)
+		if isMinimized != 0 {
+			// Restore the window if it's minimized
+			pShowWindow.Call(hwnd, uintptr(SW_RESTORE))
+		}
+
+		// Show the window
+		pShowWindow.Call(hwnd, uintptr(SW_SHOW))
+
+		// Bring window to top
+		pBringWindowToTop.Call(hwnd)
+
+		// Force window to foreground
+		pSetForegroundWindow.Call(hwnd)
+
+		// Make it the active window
+		pSetActiveWindow.Call(hwnd)
+
+		// Ensure window is positioned on top
+		pSetWindowPos.Call(
+			hwnd,
+			uintptr(HWND_TOP),
+			0, 0, 0, 0,
+			uintptr(SWP_NOSIZE|SWP_NOMOVE|SWP_SHOWWINDOW),
+		)
+	}
+}
+
+// HideWindow hides the application window
+func hideWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		pShowWindow.Call(
+			hwnd,
+			uintptr(SW_HIDE),
+		)
+	}
+}
+
+func runInBackground() {
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Error("failed to get executable path", "error", err)
+		os.Exit(1)
+	}
+	cmd := exec.Command(exe, "hidden")
+	if cmd != nil {
+		err = cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "exe", exe, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama", "exe", exe)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {}
+
+func doubleClick(ptr unsafe.Pointer) {}
+
+// checkAndHandleExistingInstance checks if another instance is running and sends the URL to it
+func checkAndHandleExistingInstance(urlSchemeRequest string) bool {
+	if urlSchemeRequest == "" {
+		return false
+	}
+
+	// Try to send URL to existing instance using wintray messaging
+	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
+		os.Exit(0)
+		return true
+	}
+
+	// No existing instance, we'll handle it ourselves
+	return false
+}

app/cmd/app/menu.h

@@ -0,0 +1,27 @@
+#ifndef MENU_H
+#define MENU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    char *label;
+    int enabled;
+    int separator;
+} menuItem;
+
+// TODO (jmorganca): these need to be forward declared in the webview.h file
+// for now but ideally they should be in this header file on windows too
+#ifndef WIN32
+int menu_get_item_count();
+void *menu_get_items();
+void menu_handle_selection(char *item);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

app/cmd/app/webview.go

@@ -0,0 +1,528 @@
+//go:build windows || darwin
+
+package main
+
+// #include "menu.h"
+import "C"
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/dialog"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/webview"
+)
+
+type Webview struct {
+	port    int
+	token   string
+	webview webview.WebView
+	mutex   sync.Mutex
+
+	Store *store.Store
+}
+
+// Run initializes the webview and starts its event loop.
+// Note: this must be called from the primary app thread
+// This returns the OS native window handle to the caller
+func (w *Webview) Run(path string) unsafe.Pointer {
+	var url string
+	if devMode {
+		// In development mode, use the local dev server
+		url = fmt.Sprintf("http://localhost:5173%s", path)
+	} else {
+		url = fmt.Sprintf("http://127.0.0.1:%d%s", w.port, path)
+	}
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	if w.webview == nil {
+		// Note: turning on debug on macos throws errors but is marginally functional for debugging
+		// TODO (jmorganca): we should pre-create the window and then provide it here to
+		// webview so we can hide it from the start and make other modifications
+		wv := webview.New(debug)
+		// start the window hidden
+		hideWindow(wv.Window())
+		wv.SetTitle("Ollama")
+
+		// TODO (jmorganca): this isn't working yet since it needs to be set
+		// on the first page load, ideally in an interstitial page like `/token`
+		// that exists only to set the cookie and redirect to /
+		// wv.Init(fmt.Sprintf(`document.cookie = "token=%s; path=/"`, w.token))
+		init := `
+		// Disable reload
+		document.addEventListener('keydown', function(e) {
+			if ((e.ctrlKey || e.metaKey) && e.key === 'r') {
+				e.preventDefault();
+				return false;
+			}
+		});
+
+		// Prevent back/forward navigation
+		window.addEventListener('popstate', function(e) {
+			e.preventDefault();
+			history.pushState(null, '', window.location.pathname);
+			return false;
+		});
+
+		// Clear history on load
+		window.addEventListener('load', function() {
+			history.pushState(null, '', window.location.pathname);
+			window.history.replaceState(null, '', window.location.pathname);
+		});
+
+		// Set token cookie
+		document.cookie = "token=` + w.token + `; path=/";
+	`
+		// Windows-specific scrollbar styling
+		if runtime.GOOS == "windows" {
+			init += `
+				// Fix scrollbar styling for Edge WebView2 on Windows only
+				function updateScrollbarStyles() {
+					const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+					const existingStyle = document.getElementById('scrollbar-style');
+					if (existingStyle) existingStyle.remove();
+					
+					const style = document.createElement('style');
+					style.id = 'scrollbar-style';
+					
+					if (isDark) {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #1a1a1a !important; }
+							::-webkit-scrollbar-thumb { background: #404040 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #505050 !important; }
+							::-webkit-scrollbar-corner { background: #1a1a1a !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					} else {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
+							::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					}
+					document.head.appendChild(style);
+				}
+				
+				window.addEventListener('load', updateScrollbarStyles);
+				window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', updateScrollbarStyles);
+			`
+		}
+		// on windows make ctrl+n open new chat
+		// TODO (jmorganca): later we should use proper accelerators
+		// once we introduce a native menu for the window
+		// this is only used on windows since macOS uses the proper accelerators
+		if runtime.GOOS == "windows" {
+			init += `
+				document.addEventListener('keydown', function(e) {
+					if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
+						e.preventDefault();
+						// Use the existing navigation method
+						history.pushState({}, '', '/c/new');
+						window.dispatchEvent(new PopStateEvent('popstate'));
+						return false;
+					}
+				});
+			`
+		}
+
+		init += `
+			window.OLLAMA_WEBSEARCH = true;
+		`
+
+		wv.Init(init)
+
+		// Add keyboard handler for zoom
+		wv.Init(`
+			window.addEventListener('keydown', function(e) {
+				// CMD/Ctrl + Plus/Equals (zoom in)
+				if ((e.metaKey || e.ctrlKey) && (e.key === '+' || e.key === '=')) {
+					e.preventDefault();
+					window.zoomIn && window.zoomIn();
+					return false;
+				}
+
+				// CMD/Ctrl + Minus (zoom out)
+				if ((e.metaKey || e.ctrlKey) && e.key === '-') {
+					e.preventDefault();
+					window.zoomOut && window.zoomOut();
+					return false;
+				}
+
+				// CMD/Ctrl + 0 (reset zoom)
+				if ((e.metaKey || e.ctrlKey) && e.key === '0') {
+					e.preventDefault();
+					window.zoomReset && window.zoomReset();
+					return false;
+				}
+			}, true);
+		`)
+
+		wv.Bind("zoomIn", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current + 0.1)
+		})
+
+		wv.Bind("zoomOut", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current - 0.1)
+		})
+
+		wv.Bind("zoomReset", func() {
+			wv.SetZoom(1.0)
+		})
+
+		wv.Bind("ready", func() {
+			showWindow(wv.Window())
+		})
+
+		wv.Bind("close", func() {
+			hideWindow(wv.Window())
+		})
+
+		// Webviews do not allow access to the file system by default, so we need to
+		// bind file system operations here
+		wv.Bind("selectModelsDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectModelsDirectoryCallback && window.__selectModelsDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Model Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		// Bind selectFiles function for selecting multiple files at once
+		wv.Bind("selectFiles", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectFilesCallback && window.__selectFilesCallback(%s)", dataJSON))
+					})
+				}
+
+				// Define allowed extensions for native dialog filtering
+				textExts := []string{
+					"pdf", "docx", "txt", "md", "csv", "json", "xml", "html", "htm",
+					"js", "jsx", "ts", "tsx", "py", "java", "cpp", "c", "cc", "h", "cs", "php", "rb",
+					"go", "rs", "swift", "kt", "scala", "sh", "bat", "yaml", "yml", "toml", "ini",
+					"cfg", "conf", "log", "rtf",
+				}
+				imageExts := []string{"png", "jpg", "jpeg", "webp"}
+				allowedExts := append(textExts, imageExts...)
+
+				// Use native multiple file selection with extension filtering
+				filenames, err := dialog.File().
+					Filter("Supported Files", allowedExts...).
+					Title("Select Files").
+					LoadMultiple()
+				if err != nil {
+					slog.Debug("Multiple file selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+
+				if len(filenames) == 0 {
+					callCallback(nil)
+					return
+				}
+
+				var files []map[string]string
+				maxFileSize := int64(10 * 1024 * 1024) // 10MB
+
+				for _, filename := range filenames {
+					// Check file extension (double-check after native dialog filtering)
+					ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
+					validExt := false
+					for _, allowedExt := range allowedExts {
+						if ext == allowedExt {
+							validExt = true
+							break
+						}
+					}
+					if !validExt {
+						slog.Warn("file extension not allowed, skipping", "filename", filepath.Base(filename), "extension", ext)
+						continue
+					}
+
+					// Check file size before reading (pre-filter large files)
+					fileStat, err := os.Stat(filename)
+					if err != nil {
+						slog.Error("failed to get file info", "error", err, "filename", filename)
+						continue
+					}
+
+					if fileStat.Size() > maxFileSize {
+						slog.Warn("file too large, skipping", "filename", filepath.Base(filename), "size", fileStat.Size())
+						continue
+					}
+
+					fileBytes, err := os.ReadFile(filename)
+					if err != nil {
+						slog.Error("failed to read file", "error", err, "filename", filename)
+						continue
+					}
+
+					mimeType := http.DetectContentType(fileBytes)
+					dataURL := fmt.Sprintf("data:%s;base64,%s", mimeType, base64.StdEncoding.EncodeToString(fileBytes))
+
+					fileResult := map[string]string{
+						"filename": filepath.Base(filename),
+						"path":     filename,
+						"dataURL":  dataURL,
+					}
+
+					files = append(files, fileResult)
+				}
+
+				if len(files) == 0 {
+					callCallback(nil)
+				} else {
+					callCallback(files)
+				}
+			}()
+		})
+
+		wv.Bind("drag", func() {
+			wv.Dispatch(func() {
+				drag(wv.Window())
+			})
+		})
+
+		wv.Bind("doubleClick", func() {
+			wv.Dispatch(func() {
+				doubleClick(wv.Window())
+			})
+		})
+
+		// Add binding for working directory selection
+		wv.Bind("selectWorkingDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectWorkingDirectoryCallback && window.__selectWorkingDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Working Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		wv.Bind("setContextMenuItems", func(items []map[string]interface{}) error {
+			menuMutex.Lock()
+			defer menuMutex.Unlock()
+
+			if len(menuItems) > 0 {
+				pinner.Unpin()
+			}
+
+			menuItems = nil
+			for _, item := range items {
+				menuItem := C.menuItem{
+					label:     C.CString(item["label"].(string)),
+					enabled:   0,
+					separator: 0,
+				}
+
+				if item["enabled"] != nil {
+					menuItem.enabled = 1
+				}
+
+				if item["separator"] != nil {
+					menuItem.separator = 1
+				}
+				menuItems = append(menuItems, menuItem)
+			}
+			return nil
+		})
+
+		// Debounce resize events
+		var resizeTimer *time.Timer
+		var resizeMutex sync.Mutex
+
+		wv.Bind("resize", func(width, height int) {
+			if w.Store != nil {
+				resizeMutex.Lock()
+				if resizeTimer != nil {
+					resizeTimer.Stop()
+				}
+				resizeTimer = time.AfterFunc(100*time.Millisecond, func() {
+					err := w.Store.SetWindowSize(width, height)
+					if err != nil {
+						slog.Error("failed to set window size", "error", err)
+					}
+				})
+				resizeMutex.Unlock()
+			}
+		})
+
+		// On Darwin, we can't have 2 threads both running global event loops
+		// but on Windows, the event loops are tied to the window, so we're
+		// able to run in both the tray and webview
+		if runtime.GOOS != "darwin" {
+			slog.Debug("starting webview event loop")
+			go func() {
+				wv.Run()
+				slog.Debug("webview event loop exited")
+			}()
+		}
+
+		if w.Store != nil {
+			width, height, err := w.Store.WindowSize()
+			if err != nil {
+				slog.Error("failed to get window size", "error", err)
+			}
+			if width > 0 && height > 0 {
+				wv.SetSize(width, height, webview.HintNone)
+			} else {
+				wv.SetSize(800, 600, webview.HintNone)
+			}
+		}
+		wv.SetSize(800, 600, webview.HintMin)
+
+		w.webview = wv
+		w.webview.Navigate(url)
+	} else {
+		w.webview.Eval(fmt.Sprintf(`
+			history.pushState({}, '', '%s');
+		`, path))
+		showWindow(w.webview.Window())
+	}
+
+	return w.webview.Window()
+}
+
+func (w *Webview) Terminate() {
+	w.mutex.Lock()
+	if w.webview == nil {
+		w.mutex.Unlock()
+		return
+	}
+
+	wv := w.webview
+	w.webview = nil
+	w.mutex.Unlock()
+	wv.Terminate()
+	wv.Destroy()
+}
+
+func (w *Webview) IsRunning() bool {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+	return w.webview != nil
+}
+
+var (
+	menuItems []C.menuItem
+	menuMutex sync.RWMutex
+	pinner    runtime.Pinner
+)
+
+//export menu_get_item_count
+func menu_get_item_count() C.int {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+	return C.int(len(menuItems))
+}
+
+//export menu_get_items
+func menu_get_items() unsafe.Pointer {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+
+	if len(menuItems) == 0 {
+		return nil
+	}
+
+	// Return pointer to the slice data
+	pinner.Pin(&menuItems[0])
+	return unsafe.Pointer(&menuItems[0])
+}
+
+//export menu_handle_selection
+func menu_handle_selection(item *C.char) {
+	wv.webview.Eval(fmt.Sprintf("window.handleContextMenuResult('%s')", C.GoString(item)))
+}

app/cmd/squirrel/Info.plist

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>English</string>
+    <key>CFBundleExecutable</key>
+    <string>Squirrel</string>
+    <key>CFBundleIconFile</key>
+    <string/>
+    <key>CFBundleIdentifier</key>
+    <string>com.github.Squirrel</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Squirrel</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>DTCompiler</key>
+    <string>com.apple.compilers.llvm.clang.1_0</string>
+    <key>DTSDKBuild</key>
+    <string>22E245</string>
+    <key>DTSDKName</key>
+    <string>macosx13.3</string>
+    <key>DTXcode</key>
+    <string>1431</string>
+    <key>DTXcodeBuild</key>
+    <string>14E300c</string>
+    <key>NSHumanReadableCopyright</key>
+    <string>Copyright © 2013 GitHub. All rights reserved.</string>
+    <key>NSPrincipalClass</key>
+    <string/>
+  </dict>
+</plist>

app/darwin/Ollama.app/Contents/Info.plist

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CFBundleDisplayName</key>
+    <string>Ollama</string>
+    <key>CFBundleExecutable</key>
+    <string>Ollama</string>
+    <key>CFBundleIconFile</key>
+    <string>icon.icns</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.electron.ollama</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Ollama</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>0.0.0</string>
+    <key>CFBundleVersion</key>
+    <string>0.0.0</string>
+    <key>DTCompiler</key>
+    <string>com.apple.compilers.llvm.clang.1_0</string>
+    <key>DTSDKBuild</key>
+    <string>22E245</string>
+    <key>DTSDKName</key>
+    <string>macosx14.0</string>
+    <key>DTXcode</key>
+    <string>1431</string>
+    <key>DTXcodeBuild</key>
+    <string>14E300c</string>
+    <key>LSApplicationCategoryType</key>
+    <string>public.app-category.developer-tools</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>14.0</string>
+    <key>LSUIElement</key>
+    <true/>
+    <key>CFBundleURLTypes</key>
+    <array>
+      <dict>
+        <key>CFBundleURLName</key>
+        <string>Ollama URL</string>
+        <key>CFBundleURLSchemes</key>
+        <array>
+          <string>ollama</string>
+        </array>
+      </dict>
+    </array>
+  </dict>
+</plist>

app/darwin/Ollama.app/Contents/Library/LaunchAgents/com.ollama.ollama.plist

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.ollama.ollama</string>
+    <key>BundleProgram</key>
+	<string>Contents/Frameworks/Squirrel.framework/Versions/A/Squirrel</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>Contents/Frameworks/Squirrel.framework/Versions/A/Squirrel</string>
+        <string>background</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>LimitLoadToSessionType</key>
+	<string>Aqua</string>
+	<key>POSIXSpawnType</key>
+	<string>Interactive</string>
+	<key>LSUIElement</key>
+	<true/>
+	<key>LSBackgroundOnly</key>
+	<false/>
+</dict>
+</plist>

app/dialog/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2018, the dialog authors.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

app/dialog/cocoa/dlg.h

@@ -0,0 +1,43 @@
+#include <objc/NSObjCRuntime.h>
+
+typedef enum {
+	MSG_YESNO,
+	MSG_ERROR,
+	MSG_INFO,
+} AlertStyle;
+
+typedef struct {
+	char* msg;
+	char* title;
+	AlertStyle style;
+} AlertDlgParams;
+
+#define LOADDLG 0
+#define SAVEDLG 1
+#define DIRDLG 2 // browse for directory
+
+typedef struct {
+	int mode; /* which dialog style to invoke (see earlier defines) */
+	char* buf; /* buffer to store selected file */
+	int nbuf; /* number of bytes allocated at buf */
+	char* title; /* title for dialog box (can be nil) */
+	void** exts; /* list of valid extensions (elements actual type is NSString*) */
+	int numext; /* number of items in exts */
+	int relaxext; /* allow other extensions? */
+	char* startDir; /* directory to start in (can be nil) */
+	char* filename; /* default filename for dialog box (can be nil) */
+	int showHidden; /* show hidden files? */
+	int allowMultiple; /* allow multiple file selection? */
+} FileDlgParams;
+
+typedef enum {
+	DLG_OK,
+	DLG_CANCEL,
+	DLG_URLFAIL,
+} DlgResult;
+
+DlgResult alertDlg(AlertDlgParams*);
+DlgResult fileDlg(FileDlgParams*);
+
+void* NSStr(void* buf, int len);
+void NSRelease(void* obj);

app/dialog/cocoa/dlg.m

@@ -0,0 +1,218 @@
+#import <Cocoa/Cocoa.h>
+#include "dlg.h"
+#include <string.h>
+#include <sys/syslimits.h>
+
+// Import UniformTypeIdentifiers for macOS 11+
+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 110000
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+#endif
+
+void* NSStr(void* buf, int len) {
+	return (void*)[[NSString alloc] initWithBytes:buf length:len encoding:NSUTF8StringEncoding];
+}
+
+void checkActivationPolicy() {
+	NSApplicationActivationPolicy policy = [NSApp activationPolicy];
+	// prohibited NSApp will not show the panel at all.
+	// It probably means that this is not run in a GUI app, that would set the policy on its own,
+	// but in a terminal app - setting it to accessory will allow dialogs to show
+	if (policy == NSApplicationActivationPolicyProhibited) {
+		[NSApp setActivationPolicy:NSApplicationActivationPolicyAccessory];
+	}
+}
+
+void NSRelease(void* obj) {
+	[(NSObject*)obj release];
+}
+
+@interface AlertDlg : NSObject {
+	AlertDlgParams* params;
+	DlgResult result;
+}
++ (AlertDlg*)init:(AlertDlgParams*)params;
+- (DlgResult)run;
+@end
+
+DlgResult alertDlg(AlertDlgParams* params) {
+	return [[AlertDlg init:params] run];
+}
+
+@implementation AlertDlg
++ (AlertDlg*)init:(AlertDlgParams*)params {
+	AlertDlg* d = [AlertDlg alloc];
+	d->params = params;
+	return d;
+}
+
+- (DlgResult)run {
+	if(![NSThread isMainThread]) {
+		[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
+		return self->result;
+	}
+	NSAlert* alert = [[NSAlert alloc] init];
+	if(self->params->title != nil) {
+		[[alert window] setTitle:[[NSString alloc] initWithUTF8String:self->params->title]];
+	}
+	[alert setMessageText:[[NSString alloc] initWithUTF8String:self->params->msg]];
+	switch (self->params->style) {
+	case MSG_YESNO:
+		[alert addButtonWithTitle:@"Yes"];
+		[alert addButtonWithTitle:@"No"];
+		break;
+	case MSG_ERROR:
+		[alert setIcon:[NSImage imageNamed:NSImageNameCaution]];
+		[alert addButtonWithTitle:@"OK"];
+		break;
+	case MSG_INFO:
+		[alert setIcon:[NSImage imageNamed:NSImageNameInfo]];
+		[alert addButtonWithTitle:@"OK"];
+		break;
+	}
+
+	checkActivationPolicy();
+
+	self->result = [alert runModal] == NSAlertFirstButtonReturn ? DLG_OK : DLG_CANCEL;
+	return self->result;
+}
+@end
+
+@interface FileDlg : NSObject {
+	FileDlgParams* params;
+	DlgResult result;
+}
++ (FileDlg*)init:(FileDlgParams*)params;
+- (DlgResult)run;
+@end
+
+DlgResult fileDlg(FileDlgParams* params) {
+	return [[FileDlg init:params] run];
+}
+
+@implementation FileDlg
++ (FileDlg*)init:(FileDlgParams*)params {
+	FileDlg* d = [FileDlg alloc];
+	d->params = params;
+	return d;
+}
+
+- (DlgResult)run {
+	if(![NSThread isMainThread]) {
+		[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
+	} else if(self->params->mode == SAVEDLG) {
+		self->result = [self save];
+	} else {
+		self->result = [self load];
+	}
+	return self->result;
+}
+
+- (NSInteger)runPanel:(NSSavePanel*)panel {
+	[panel setFloatingPanel:YES];
+	[panel setShowsHiddenFiles:self->params->showHidden ? YES : NO];
+	[panel setCanCreateDirectories:YES];
+	if(self->params->title != nil) {
+		[panel setTitle:[[NSString alloc] initWithUTF8String:self->params->title]];
+	}
+	// Use modern allowedContentTypes API for better file type support (especially video files)
+	if(self->params->numext > 0) {
+		NSMutableArray *utTypes = [NSMutableArray arrayWithCapacity:self->params->numext];
+		NSString** exts = (NSString**)self->params->exts;
+		for(int i = 0; i < self->params->numext; i++) {
+			UTType *type = [UTType typeWithFilenameExtension:exts[i]];
+			if(type) {
+				[utTypes addObject:type];
+			}
+		}
+		if([utTypes count] > 0) {
+			[panel setAllowedContentTypes:utTypes];
+		}
+	}
+	if(self->params->relaxext) {
+		[panel setAllowsOtherFileTypes:YES];
+	}
+	if(self->params->startDir) {
+		[panel setDirectoryURL:[NSURL URLWithString:[[NSString alloc] initWithUTF8String:self->params->startDir]]];
+	}
+	if(self->params->filename != nil) {
+		[panel setNameFieldStringValue:[[NSString alloc] initWithUTF8String:self->params->filename]];
+	}
+
+	checkActivationPolicy();
+
+	return [panel runModal];
+}
+
+- (DlgResult)save {
+	NSSavePanel* panel = [NSSavePanel savePanel];
+	if(![self runPanel:panel]) {
+		return DLG_CANCEL;
+	} else if(![[panel URL] getFileSystemRepresentation:self->params->buf maxLength:self->params->nbuf]) {
+		return DLG_URLFAIL;
+	}
+	return DLG_OK;
+}
+
+- (DlgResult)load {
+	NSOpenPanel* panel = [NSOpenPanel openPanel];
+	if(self->params->mode == DIRDLG) {
+		[panel setCanChooseDirectories:YES];
+		[panel setCanChooseFiles:NO];
+	}
+	
+	if(self->params->allowMultiple) {
+		[panel setAllowsMultipleSelection:YES];
+	}
+	
+	if(![self runPanel:panel]) {
+		return DLG_CANCEL;
+	}
+	
+	NSArray* urls = [panel URLs];
+	if([urls count] == 0) {
+		return DLG_CANCEL;
+	}
+	
+	if(self->params->allowMultiple) {
+		// For multiple files, we need to return all paths separated by null bytes
+		char* bufPtr = self->params->buf;
+		int remainingBuf = self->params->nbuf;
+		
+		// Calculate total required buffer size first
+		int totalSize = 0;
+		for(NSURL* url in urls) {
+			char tempBuf[PATH_MAX];
+			if(![url getFileSystemRepresentation:tempBuf maxLength:PATH_MAX]) {
+				return DLG_URLFAIL;
+			}
+			totalSize += strlen(tempBuf) + 1; // +1 for null terminator
+		}
+		totalSize += 1; // Final null terminator
+
+		if(totalSize > self->params->nbuf) {
+			// Not enough buffer space
+			return DLG_URLFAIL;
+		}
+
+		// Now actually copy the paths (we know we have space)
+		bufPtr = self->params->buf;
+		for(NSURL* url in urls) {
+			char tempBuf[PATH_MAX];
+			[url getFileSystemRepresentation:tempBuf maxLength:PATH_MAX];
+			int pathLen = strlen(tempBuf);
+			strcpy(bufPtr, tempBuf);
+			bufPtr += pathLen + 1;
+		}
+		*bufPtr = '\0'; // Final null terminator
+	} else {
+		// Single file/directory selection - write path to buffer
+		NSURL* url = [urls firstObject];
+		if(![url getFileSystemRepresentation:self->params->buf maxLength:self->params->nbuf]) {
+			return DLG_URLFAIL;
+		}
+	}
+	
+	return DLG_OK;
+}
+
+@end

app/dialog/cocoa/dlg_darwin.go

@@ -0,0 +1,183 @@
+package cocoa
+
+// #cgo darwin LDFLAGS: -framework Cocoa -framework UniformTypeIdentifiers
+// #include <stdlib.h>
+// #include <sys/syslimits.h>
+// #include "dlg.h"
+import "C"
+
+import (
+	"bytes"
+	"errors"
+	"unsafe"
+)
+
+type AlertParams struct {
+	p C.AlertDlgParams
+}
+
+func mkAlertParams(msg, title string, style C.AlertStyle) *AlertParams {
+	a := AlertParams{C.AlertDlgParams{msg: C.CString(msg), style: style}}
+	if title != "" {
+		a.p.title = C.CString(title)
+	}
+	return &a
+}
+
+func (a *AlertParams) run() C.DlgResult {
+	return C.alertDlg(&a.p)
+}
+
+func (a *AlertParams) free() {
+	C.free(unsafe.Pointer(a.p.msg))
+	if a.p.title != nil {
+		C.free(unsafe.Pointer(a.p.title))
+	}
+}
+
+func nsStr(s string) unsafe.Pointer {
+	return C.NSStr(unsafe.Pointer(&[]byte(s)[0]), C.int(len(s)))
+}
+
+func YesNoDlg(msg, title string) bool {
+	a := mkAlertParams(msg, title, C.MSG_YESNO)
+	defer a.free()
+	return a.run() == C.DLG_OK
+}
+
+func InfoDlg(msg, title string) {
+	a := mkAlertParams(msg, title, C.MSG_INFO)
+	defer a.free()
+	a.run()
+}
+
+func ErrorDlg(msg, title string) {
+	a := mkAlertParams(msg, title, C.MSG_ERROR)
+	defer a.free()
+	a.run()
+}
+
+const (
+	BUFSIZE             = C.PATH_MAX
+	MULTI_FILE_BUF_SIZE = 32768
+)
+
+// MultiFileDlg opens a file dialog that allows multiple file selection
+func MultiFileDlg(title string, exts []string, relaxExt bool, startDir string, showHidden bool) ([]string, error) {
+	return fileDlgWithOptions(C.LOADDLG, title, exts, relaxExt, startDir, "", showHidden, true)
+}
+
+// FileDlg opens a file dialog for single file selection (kept for compatibility)
+func FileDlg(save bool, title string, exts []string, relaxExt bool, startDir string, filename string, showHidden bool) (string, error) {
+	mode := C.LOADDLG
+	if save {
+		mode = C.SAVEDLG
+	}
+	files, err := fileDlgWithOptions(mode, title, exts, relaxExt, startDir, filename, showHidden, false)
+	if err != nil {
+		return "", err
+	}
+	if len(files) == 0 {
+		return "", nil
+	}
+	return files[0], nil
+}
+
+func DirDlg(title string, startDir string, showHidden bool) (string, error) {
+	files, err := fileDlgWithOptions(C.DIRDLG, title, nil, false, startDir, "", showHidden, false)
+	if err != nil {
+		return "", err
+	}
+	if len(files) == 0 {
+		return "", nil
+	}
+	return files[0], nil
+}
+
+// fileDlgWithOptions is the unified file dialog function that handles both single and multiple selection
+func fileDlgWithOptions(mode int, title string, exts []string, relaxExt bool, startDir, filename string, showHidden, allowMultiple bool) ([]string, error) {
+	// Use larger buffer for multiple files, smaller for single
+	bufSize := BUFSIZE
+	if allowMultiple {
+		bufSize = MULTI_FILE_BUF_SIZE
+	}
+
+	p := C.FileDlgParams{
+		mode: C.int(mode),
+		nbuf: C.int(bufSize),
+	}
+
+	if allowMultiple {
+		p.allowMultiple = C.int(1) // Enable multiple selection //nolint:structcheck
+	}
+	if showHidden {
+		p.showHidden = 1
+	}
+
+	p.buf = (*C.char)(C.malloc(C.size_t(bufSize)))
+	defer C.free(unsafe.Pointer(p.buf))
+	buf := (*(*[MULTI_FILE_BUF_SIZE]byte)(unsafe.Pointer(p.buf)))[:bufSize]
+
+	if title != "" {
+		p.title = C.CString(title)
+		defer C.free(unsafe.Pointer(p.title))
+	}
+	if startDir != "" {
+		p.startDir = C.CString(startDir)
+		defer C.free(unsafe.Pointer(p.startDir))
+	}
+	if filename != "" {
+		p.filename = C.CString(filename)
+		defer C.free(unsafe.Pointer(p.filename))
+	}
+
+	if len(exts) > 0 {
+		if len(exts) > 999 {
+			panic("more than 999 extensions not supported")
+		}
+		ptrSize := int(unsafe.Sizeof(&title))
+		p.exts = (*unsafe.Pointer)(C.malloc(C.size_t(ptrSize * len(exts))))
+		defer C.free(unsafe.Pointer(p.exts))
+		cext := (*(*[999]unsafe.Pointer)(unsafe.Pointer(p.exts)))[:]
+		for i, ext := range exts {
+			cext[i] = nsStr(ext)
+			defer C.NSRelease(cext[i])
+		}
+		p.numext = C.int(len(exts))
+		if relaxExt {
+			p.relaxext = 1
+		}
+	}
+
+	// Execute dialog and parse results
+	switch C.fileDlg(&p) {
+	case C.DLG_OK:
+		if allowMultiple {
+			// Parse multiple null-terminated strings from buffer
+			var files []string
+			start := 0
+			for i := range len(buf) - 1 {
+				if buf[i] == 0 {
+					if i > start {
+						files = append(files, string(buf[start:i]))
+					}
+					start = i + 1
+					// Check for double null (end of list)
+					if i+1 < len(buf) && buf[i+1] == 0 {
+						break
+					}
+				}
+			}
+			return files, nil
+		} else {
+			// Single file - return as array for consistency
+			filename := string(buf[:bytes.Index(buf, []byte{0})])
+			return []string{filename}, nil
+		}
+	case C.DLG_CANCEL:
+		return nil, nil
+	case C.DLG_URLFAIL:
+		return nil, errors.New("failed to get file-system representation for selected URL")
+	}
+	panic("unhandled case")
+}

app/dialog/dlgs.go

@@ -0,0 +1,182 @@
+//go:build windows || darwin
+
+// Package dialog provides a simple cross-platform common dialog API.
+// Eg. to prompt the user with a yes/no dialog:
+//
+//	if dialog.MsgDlg("%s", "Do you want to continue?").YesNo() {
+//	    // user pressed Yes
+//	}
+//
+// The general usage pattern is to call one of the toplevel *Dlg functions
+// which return a *Builder structure. From here you can optionally call
+// configuration functions (eg. Title) to customise the dialog, before
+// using a launcher function to run the dialog.
+package dialog
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrCancelled is an error returned when a user cancels/closes a dialog.
+var ErrCancelled = errors.New("Cancelled")
+
+// Cancelled refers to ErrCancelled.
+// Deprecated: Use ErrCancelled instead.
+var Cancelled = ErrCancelled
+
+// Dlg is the common type for dialogs.
+type Dlg struct {
+	Title string
+}
+
+// MsgBuilder is used for creating message boxes.
+type MsgBuilder struct {
+	Dlg
+	Msg string
+}
+
+// Message initialises a MsgBuilder with the provided message.
+func Message(format string, args ...interface{}) *MsgBuilder {
+	return &MsgBuilder{Msg: fmt.Sprintf(format, args...)}
+}
+
+// Title specifies what the title of the message dialog will be.
+func (b *MsgBuilder) Title(title string) *MsgBuilder {
+	b.Dlg.Title = title
+	return b
+}
+
+// YesNo spawns the message dialog with two buttons, "Yes" and "No".
+// Returns true iff the user selected "Yes".
+func (b *MsgBuilder) YesNo() bool {
+	return b.yesNo()
+}
+
+// Info spawns the message dialog with an information icon and single button, "Ok".
+func (b *MsgBuilder) Info() {
+	b.info()
+}
+
+// Error spawns the message dialog with an error icon and single button, "Ok".
+func (b *MsgBuilder) Error() {
+	b.error()
+}
+
+// FileFilter represents a category of files (eg. audio files, spreadsheets).
+type FileFilter struct {
+	Desc       string
+	Extensions []string
+}
+
+// FileBuilder is used for creating file browsing dialogs.
+type FileBuilder struct {
+	Dlg
+	StartDir        string
+	StartFile       string
+	Filters         []FileFilter
+	ShowHiddenFiles bool
+}
+
+// File initialises a FileBuilder using the default configuration.
+func File() *FileBuilder {
+	return &FileBuilder{}
+}
+
+// Title specifies the title to be used for the dialog.
+func (b *FileBuilder) Title(title string) *FileBuilder {
+	b.Dlg.Title = title
+	return b
+}
+
+// Filter adds a category of files to the types allowed by the dialog. Multiple
+// calls to Filter are cumulative - any of the provided categories will be allowed.
+// By default all files can be selected.
+//
+// The special extension '*' allows all files to be selected when the Filter is active.
+func (b *FileBuilder) Filter(desc string, extensions ...string) *FileBuilder {
+	filt := FileFilter{desc, extensions}
+	if len(filt.Extensions) == 0 {
+		filt.Extensions = append(filt.Extensions, "*")
+	}
+	b.Filters = append(b.Filters, filt)
+	return b
+}
+
+// SetStartDir specifies the initial directory of the dialog.
+func (b *FileBuilder) SetStartDir(startDir string) *FileBuilder {
+	b.StartDir = startDir
+	return b
+}
+
+// SetStartFile specifies the initial file name of the dialog.
+func (b *FileBuilder) SetStartFile(startFile string) *FileBuilder {
+	b.StartFile = startFile
+	return b
+}
+
+// ShowHiddenFiles sets whether hidden files should be visible in the dialog.
+func (b *FileBuilder) ShowHidden(show bool) *FileBuilder {
+	b.ShowHiddenFiles = show
+	return b
+}
+
+// Load spawns the file selection dialog using the configured settings,
+// asking the user to select a single file. Returns ErrCancelled as the error
+// if the user cancels or closes the dialog.
+func (b *FileBuilder) Load() (string, error) {
+	return b.load()
+}
+
+// LoadMultiple spawns the file selection dialog using the configured settings,
+// asking the user to select multiple files. Returns ErrCancelled as the error
+// if the user cancels or closes the dialog.
+func (b *FileBuilder) LoadMultiple() ([]string, error) {
+	return b.loadMultiple()
+}
+
+// Save spawns the file selection dialog using the configured settings,
+// asking the user for a filename to save as. If the chosen file exists, the
+// user is prompted whether they want to overwrite the file. Returns
+// ErrCancelled as the error if the user cancels/closes the dialog, or selects
+// not to overwrite the file.
+func (b *FileBuilder) Save() (string, error) {
+	return b.save()
+}
+
+// DirectoryBuilder is used for directory browse dialogs.
+type DirectoryBuilder struct {
+	Dlg
+	StartDir        string
+	ShowHiddenFiles bool
+}
+
+// Directory initialises a DirectoryBuilder using the default configuration.
+func Directory() *DirectoryBuilder {
+	return &DirectoryBuilder{}
+}
+
+// Browse spawns the directory selection dialog using the configured settings,
+// asking the user to select a single folder. Returns ErrCancelled as the error
+// if the user cancels or closes the dialog.
+func (b *DirectoryBuilder) Browse() (string, error) {
+	return b.browse()
+}
+
+// Title specifies the title to be used for the dialog.
+func (b *DirectoryBuilder) Title(title string) *DirectoryBuilder {
+	b.Dlg.Title = title
+	return b
+}
+
+// StartDir specifies the initial directory to be used for the dialog.
+func (b *DirectoryBuilder) SetStartDir(dir string) *DirectoryBuilder {
+	b.StartDir = dir
+	return b
+}
+
+// ShowHiddenFiles sets whether hidden files should be visible in the dialog.
+func (b *DirectoryBuilder) ShowHidden(show bool) *DirectoryBuilder {
+	b.ShowHiddenFiles = show
+	return b
+}

app/dialog/dlgs_darwin.go

@@ -0,0 +1,82 @@
+package dialog
+
+import (
+	"github.com/ollama/ollama/app/dialog/cocoa"
+)
+
+func (b *MsgBuilder) yesNo() bool {
+	return cocoa.YesNoDlg(b.Msg, b.Dlg.Title)
+}
+
+func (b *MsgBuilder) info() {
+	cocoa.InfoDlg(b.Msg, b.Dlg.Title)
+}
+
+func (b *MsgBuilder) error() {
+	cocoa.ErrorDlg(b.Msg, b.Dlg.Title)
+}
+
+func (b *FileBuilder) load() (string, error) {
+	return b.run(false)
+}
+
+func (b *FileBuilder) loadMultiple() ([]string, error) {
+	return b.runMultiple()
+}
+
+func (b *FileBuilder) save() (string, error) {
+	return b.run(true)
+}
+
+func (b *FileBuilder) run(save bool) (string, error) {
+	star := false
+	var exts []string
+	for _, filt := range b.Filters {
+		for _, ext := range filt.Extensions {
+			if ext == "*" {
+				star = true
+			} else {
+				exts = append(exts, ext)
+			}
+		}
+	}
+	if star && save {
+		/* OSX doesn't allow the user to switch visible file types/extensions. Also
+		** NSSavePanel's allowsOtherFileTypes property has no effect for an open
+		** dialog, so if "*" is a possible extension we must always show all files. */
+		exts = nil
+	}
+	f, err := cocoa.FileDlg(save, b.Dlg.Title, exts, star, b.StartDir, b.StartFile, b.ShowHiddenFiles)
+	if f == "" && err == nil {
+		return "", ErrCancelled
+	}
+	return f, err
+}
+
+func (b *FileBuilder) runMultiple() ([]string, error) {
+	star := false
+	var exts []string
+	for _, filt := range b.Filters {
+		for _, ext := range filt.Extensions {
+			if ext == "*" {
+				star = true
+			} else {
+				exts = append(exts, ext)
+			}
+		}
+	}
+
+	files, err := cocoa.MultiFileDlg(b.Dlg.Title, exts, star, b.StartDir, b.ShowHiddenFiles)
+	if len(files) == 0 && err == nil {
+		return nil, ErrCancelled
+	}
+	return files, err
+}
+
+func (b *DirectoryBuilder) browse() (string, error) {
+	f, err := cocoa.DirDlg(b.Dlg.Title, b.StartDir, b.ShowHiddenFiles)
+	if f == "" && err == nil {
+		return "", ErrCancelled
+	}
+	return f, err
+}

app/dialog/dlgs_windows.go

@@ -0,0 +1,241 @@
+package dialog
+
+import (
+	"fmt"
+	"reflect"
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+
+	"github.com/TheTitanrain/w32"
+)
+
+const multiFileBufferSize = w32.MAX_PATH * 10
+
+type WinDlgError int
+
+func (e WinDlgError) Error() string {
+	return fmt.Sprintf("CommDlgExtendedError: %#x", int(e))
+}
+
+func err() error {
+	e := w32.CommDlgExtendedError()
+	if e == 0 {
+		return ErrCancelled
+	}
+	return WinDlgError(e)
+}
+
+func (b *MsgBuilder) yesNo() bool {
+	r := w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Confirm?"), w32.MB_YESNO)
+	return r == w32.IDYES
+}
+
+func (b *MsgBuilder) info() {
+	w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Information"), w32.MB_OK|w32.MB_ICONINFORMATION)
+}
+
+func (b *MsgBuilder) error() {
+	w32.MessageBox(w32.HWND(0), b.Msg, firstOf(b.Dlg.Title, "Error"), w32.MB_OK|w32.MB_ICONERROR)
+}
+
+type filedlg struct {
+	buf     []uint16
+	filters []uint16
+	opf     *w32.OPENFILENAME
+}
+
+func (d filedlg) Filename() string {
+	i := 0
+	for i < len(d.buf) && d.buf[i] != 0 {
+		i++
+	}
+	return string(utf16.Decode(d.buf[:i]))
+}
+
+func (d filedlg) parseMultipleFilenames() []string {
+	var files []string
+	i := 0
+
+	// Find first null terminator (directory path)
+	for i < len(d.buf) && d.buf[i] != 0 {
+		i++
+	}
+
+	if i >= len(d.buf) {
+		return files
+	}
+
+	// Get directory path
+	dirPath := string(utf16.Decode(d.buf[:i]))
+	i++ // Skip null terminator
+
+	// Check if there are more files (multiple selection)
+	if i < len(d.buf) && d.buf[i] != 0 {
+		// Multiple files selected - parse filenames
+		for i < len(d.buf) {
+			start := i
+			// Find next null terminator
+			for i < len(d.buf) && d.buf[i] != 0 {
+				i++
+			}
+			if i >= len(d.buf) {
+				break
+			}
+
+			if start < i {
+				filename := string(utf16.Decode(d.buf[start:i]))
+				if dirPath != "" {
+					files = append(files, dirPath+"\\"+filename)
+				} else {
+					files = append(files, filename)
+				}
+			}
+			i++ // Skip null terminator
+			if i >= len(d.buf) || d.buf[i] == 0 {
+				break // End of list
+			}
+		}
+	} else {
+		// Single file selected
+		files = append(files, dirPath)
+	}
+
+	return files
+}
+
+func (b *FileBuilder) load() (string, error) {
+	d := openfile(w32.OFN_FILEMUSTEXIST|w32.OFN_NOCHANGEDIR, b)
+	if w32.GetOpenFileName(d.opf) {
+		return d.Filename(), nil
+	}
+	return "", err()
+}
+
+func (b *FileBuilder) loadMultiple() ([]string, error) {
+	d := openfile(w32.OFN_FILEMUSTEXIST|w32.OFN_NOCHANGEDIR|w32.OFN_ALLOWMULTISELECT|w32.OFN_EXPLORER, b)
+	d.buf = make([]uint16, multiFileBufferSize)
+	d.opf.File = utf16ptr(d.buf)
+	d.opf.MaxFile = uint32(len(d.buf))
+
+	if w32.GetOpenFileName(d.opf) {
+		return d.parseMultipleFilenames(), nil
+	}
+	return nil, err()
+}
+
+func (b *FileBuilder) save() (string, error) {
+	d := openfile(w32.OFN_OVERWRITEPROMPT|w32.OFN_NOCHANGEDIR, b)
+	if w32.GetSaveFileName(d.opf) {
+		return d.Filename(), nil
+	}
+	return "", err()
+}
+
+/* syscall.UTF16PtrFromString not sufficient because we need to encode embedded NUL bytes */
+func utf16ptr(utf16 []uint16) *uint16 {
+	if utf16[len(utf16)-1] != 0 {
+		panic("refusing to make ptr to non-NUL terminated utf16 slice")
+	}
+	h := (*reflect.SliceHeader)(unsafe.Pointer(&utf16))
+	return (*uint16)(unsafe.Pointer(h.Data))
+}
+
+func utf16slice(ptr *uint16) []uint16 { //nolint:unused
+	hdr := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(ptr)), Len: 1, Cap: 1}
+	slice := *((*[]uint16)(unsafe.Pointer(&hdr))) //nolint:govet
+	i := 0
+	for slice[len(slice)-1] != 0 {
+		i++
+	}
+	hdr.Len = i
+	slice = *((*[]uint16)(unsafe.Pointer(&hdr))) //nolint:govet
+	return slice
+}
+
+func openfile(flags uint32, b *FileBuilder) (d filedlg) {
+	d.buf = make([]uint16, w32.MAX_PATH)
+	if b.StartFile != "" {
+		initialName, _ := syscall.UTF16FromString(b.StartFile)
+		for i := 0; i < len(initialName) && i < w32.MAX_PATH; i++ {
+			d.buf[i] = initialName[i]
+		}
+	}
+	d.opf = &w32.OPENFILENAME{
+		File:    utf16ptr(d.buf),
+		MaxFile: uint32(len(d.buf)),
+		Flags:   flags,
+	}
+	d.opf.StructSize = uint32(unsafe.Sizeof(*d.opf))
+	if b.StartDir != "" {
+		d.opf.InitialDir, _ = syscall.UTF16PtrFromString(b.StartDir)
+	}
+	if b.Dlg.Title != "" {
+		d.opf.Title, _ = syscall.UTF16PtrFromString(b.Dlg.Title)
+	}
+	for _, filt := range b.Filters {
+		/* build utf16 string of form "Music File\0*.mp3;*.ogg;*.wav;\0" */
+		d.filters = append(d.filters, utf16.Encode([]rune(filt.Desc))...)
+		d.filters = append(d.filters, 0)
+		for _, ext := range filt.Extensions {
+			s := fmt.Sprintf("*.%s;", ext)
+			d.filters = append(d.filters, utf16.Encode([]rune(s))...)
+		}
+		d.filters = append(d.filters, 0)
+	}
+	if d.filters != nil {
+		d.filters = append(d.filters, 0, 0) // two extra NUL chars to terminate the list
+		d.opf.Filter = utf16ptr(d.filters)
+	}
+	return d
+}
+
+type dirdlg struct {
+	bi *w32.BROWSEINFO
+}
+
+const (
+	bffm_INITIALIZED     = 1
+	bffm_SELCHANGED      = 2
+	bffm_VALIDATEFAILEDA = 3
+	bffm_VALIDATEFAILEDW = 4
+	bffm_SETSTATUSTEXTA  = (w32.WM_USER + 100)
+	bffm_SETSTATUSTEXTW  = (w32.WM_USER + 104)
+	bffm_ENABLEOK        = (w32.WM_USER + 101)
+	bffm_SETSELECTIONA   = (w32.WM_USER + 102)
+	bffm_SETSELECTIONW   = (w32.WM_USER + 103)
+	bffm_SETOKTEXT       = (w32.WM_USER + 105)
+	bffm_SETEXPANDED     = (w32.WM_USER + 106)
+	bffm_SETSTATUSTEXT   = bffm_SETSTATUSTEXTW
+	bffm_SETSELECTION    = bffm_SETSELECTIONW
+	bffm_VALIDATEFAILED  = bffm_VALIDATEFAILEDW
+)
+
+func callbackDefaultDir(hwnd w32.HWND, msg uint, lParam, lpData uintptr) int {
+	if msg == bffm_INITIALIZED {
+		_ = w32.SendMessage(hwnd, bffm_SETSELECTION, w32.TRUE, lpData)
+	}
+	return 0
+}
+
+func selectdir(b *DirectoryBuilder) (d dirdlg) {
+	d.bi = &w32.BROWSEINFO{Flags: w32.BIF_RETURNONLYFSDIRS | w32.BIF_NEWDIALOGSTYLE}
+	if b.Dlg.Title != "" {
+		d.bi.Title, _ = syscall.UTF16PtrFromString(b.Dlg.Title)
+	}
+	if b.StartDir != "" {
+		s16, _ := syscall.UTF16PtrFromString(b.StartDir)
+		d.bi.LParam = uintptr(unsafe.Pointer(s16))
+		d.bi.CallbackFunc = syscall.NewCallback(callbackDefaultDir)
+	}
+	return d
+}
+
+func (b *DirectoryBuilder) browse() (string, error) {
+	d := selectdir(b)
+	res := w32.SHBrowseForFolder(d.bi)
+	if res == 0 {
+		return "", ErrCancelled
+	}
+	return w32.SHGetPathFromIDList(res), nil
+}

app/dialog/util.go

@@ -0,0 +1,12 @@
+//go:build windows
+
+package dialog
+
+func firstOf(args ...string) string {
+	for _, arg := range args {
+		if arg != "" {
+			return arg
+		}
+	}
+	return ""
+}

app/format/field.go

@@ -0,0 +1,30 @@
+//go:build windows || darwin
+
+package format
+
+import (
+	"strings"
+	"unicode"
+)
+
+// KebabCase converts a string from camelCase or PascalCase to kebab-case.
+// (e.g. "camelCase" -> "camel-case")
+func KebabCase(str string) string {
+	var result strings.Builder
+
+	for i, char := range str {
+		if i > 0 {
+			prevChar := rune(str[i-1])
+
+			// Add hyphen before uppercase letters
+			if unicode.IsUpper(char) &&
+				(unicode.IsLower(prevChar) || unicode.IsDigit(prevChar) ||
+					(i < len(str)-1 && unicode.IsLower(rune(str[i+1])))) {
+				result.WriteRune('-')
+			}
+		}
+		result.WriteRune(unicode.ToLower(char))
+	}
+
+	return result.String()
+}

app/format/field_test.go

@@ -0,0 +1,34 @@
+//go:build windows || darwin
+
+package format
+
+import "testing"
+
+func TestKebabCase(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"already-kebab-case", "already-kebab-case"},
+		{"simpleCamelCase", "simple-camel-case"},
+		{"PascalCase", "pascal-case"},
+		{"camelCaseWithNumber123", "camel-case-with-number123"},
+		{"APIResponse", "api-response"},
+		{"mixedCASE", "mixed-case"},
+		{"WithACRONYMS", "with-acronyms"},
+		{"ALLCAPS", "allcaps"},
+		{"camelCaseWITHMixedACRONYMS", "camel-case-with-mixed-acronyms"},
+		{"numbers123in456string", "numbers123in456string"},
+		{"5", "5"},
+		{"S", "s"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			result := KebabCase(tt.input)
+			if result != tt.expected {
+				t.Errorf("toKebabCase(%q) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}

app/logrotate/logrotate.go

@@ -0,0 +1,45 @@
+//go:build windows || darwin
+
+// package logrotate provides utilities for rotating logs
+// TODO (jmorgan): this most likely doesn't need it's own
+// package and can be moved to app where log files are created
+package logrotate
+
+import (
+	"log/slog"
+	"os"
+	"strconv"
+	"strings"
+)
+
+const MaxLogFiles = 5
+
+func Rotate(filename string) {
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
+		return
+	}
+
+	index := strings.LastIndex(filename, ".")
+	pre := filename[:index]
+	post := "." + filename[index+1:]
+	for i := MaxLogFiles; i > 0; i-- {
+		older := pre + "-" + strconv.Itoa(i) + post
+		newer := pre + "-" + strconv.Itoa(i-1) + post
+		if i == 1 {
+			newer = pre + post
+		}
+		if _, err := os.Stat(newer); err == nil {
+			if _, err := os.Stat(older); err == nil {
+				err := os.Remove(older)
+				if err != nil {
+					slog.Warn("Failed to remove older log", "older", older, "error", err)
+					continue
+				}
+			}
+			err := os.Rename(newer, older)
+			if err != nil {
+				slog.Warn("Failed to rotate log", "older", older, "newer", newer, "error", err)
+			}
+		}
+	}
+}

app/logrotate/logrotate_test.go

@@ -0,0 +1,70 @@
+//go:build windows || darwin
+
+package logrotate
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+)
+
+func TestRotate(t *testing.T) {
+	logDir := t.TempDir()
+	logFile := filepath.Join(logDir, "testlog.log")
+
+	// No log exists
+	Rotate(logFile)
+
+	if err := os.WriteFile(logFile, []byte("1"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(logFile); os.IsNotExist(err) {
+		t.Fatal("expected log file to exist")
+	}
+
+	// First rotation
+	Rotate(logFile)
+	if _, err := os.Stat(filepath.Join(logDir, "testlog-1.log")); os.IsNotExist(err) {
+		t.Fatal("expected rotated log file to exist")
+	}
+	if _, err := os.Stat(filepath.Join(logDir, "testlog-2.log")); !os.IsNotExist(err) {
+		t.Fatal("expected no second rotated log file")
+	}
+	if _, err := os.Stat(logFile); !os.IsNotExist(err) {
+		t.Fatal("expected original log file to be moved")
+	}
+
+	// Should be a no-op without a new log
+	Rotate(logFile)
+	if _, err := os.Stat(filepath.Join(logDir, "testlog-1.log")); os.IsNotExist(err) {
+		t.Fatal("expected rotated log file to still exist")
+	}
+	if _, err := os.Stat(filepath.Join(logDir, "testlog-2.log")); !os.IsNotExist(err) {
+		t.Fatal("expected no second rotated log file")
+	}
+	if _, err := os.Stat(logFile); !os.IsNotExist(err) {
+		t.Fatal("expected no original log file")
+	}
+
+	for i := 2; i <= MaxLogFiles+1; i++ {
+		if err := os.WriteFile(logFile, []byte(strconv.Itoa(i)), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := os.Stat(logFile); os.IsNotExist(err) {
+			t.Fatal("expected log file to exist")
+		}
+		Rotate(logFile)
+		if _, err := os.Stat(logFile); !os.IsNotExist(err) {
+			t.Fatal("expected log file to be moved")
+		}
+		for j := 1; j < i; j++ {
+			if _, err := os.Stat(filepath.Join(logDir, "testlog-"+strconv.Itoa(j)+".log")); os.IsNotExist(err) {
+				t.Fatalf("expected rotated log file %d to exist", j)
+			}
+		}
+		if _, err := os.Stat(filepath.Join(logDir, "testlog-"+strconv.Itoa(i+1)+".log")); !os.IsNotExist(err) {
+			t.Fatalf("expected no rotated log file %d", i+1)
+		}
+	}
+}

app/ollama.iss

@@ -0,0 +1,374 @@
+; Inno Setup Installer for Ollama
+;
+; To build the installer use the build script invoked from the top of the source tree
+; 
+; powershell -ExecutionPolicy Bypass -File .\scripts\build_windows.ps
+
+
+#define MyAppName "Ollama"
+#if GetEnv("PKG_VERSION") != ""
+  #define MyAppVersion GetEnv("PKG_VERSION")
+#else
+  #define MyAppVersion "0.0.0"
+#endif
+#define MyAppPublisher "Ollama"
+#define MyAppURL "https://ollama.com/"
+#define MyAppExeName "ollama app.exe"
+#define MyIcon ".\assets\app.ico"
+
+[Setup]
+; NOTE: The value of AppId uniquely identifies this application. Do not use the same AppId value in installers for other applications.
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+AppId={{44E83376-CE68-45EB-8FC1-393500EB558C}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+VersionInfoVersion={#MyAppVersion}
+;AppVerName={#MyAppName} {#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+ArchitecturesAllowed=x64compatible arm64
+ArchitecturesInstallIn64BitMode=x64compatible arm64
+DefaultDirName={localappdata}\Programs\{#MyAppName}
+DefaultGroupName={#MyAppName}
+DisableProgramGroupPage=yes
+PrivilegesRequired=lowest
+OutputBaseFilename="OllamaSetup"
+SetupIconFile={#MyIcon}
+UninstallDisplayIcon={uninstallexe}
+Compression=lzma2/ultra64
+LZMAUseSeparateProcess=yes
+LZMANumBlockThreads=8
+SolidCompression=yes
+WizardStyle=modern
+ChangesEnvironment=yes
+OutputDir=..\dist\
+
+; Disable logging once everything's battle tested
+; Filename will be %TEMP%\Setup Log*.txt
+SetupLogging=yes
+CloseApplications=no
+RestartApplications=no
+RestartIfNeededByRun=no
+
+; https://jrsoftware.org/ishelp/index.php?topic=setup_wizardimagefile
+WizardSmallImageFile=.\assets\setup.bmp
+
+; Ollama requires Windows 10 22H2 or newer for proper unicode rendering
+; TODO: consider setting this to 10.0.19045
+MinVersion=10.0.10240
+
+; First release that supports WinRT UI Composition for win32 apps
+; MinVersion=10.0.17134
+; First release with XAML Islands - possible UI path forward
+; MinVersion=10.0.18362
+
+; quiet...
+DisableDirPage=yes
+DisableFinishedPage=yes
+DisableReadyMemo=yes
+DisableReadyPage=yes
+DisableStartupPrompt=yes
+
+; TODO - percentage can't be set less than 100, so how to make it shorter?
+; WizardSizePercent=100,80
+
+#if GetEnv("KEY_CONTAINER")
+SignTool=MySignTool
+SignedUninstaller=yes
+#endif
+
+SetupMutex=OllamaSetupMutex
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[LangOptions]
+DialogFontSize=12
+
+[Files]
+#if FileExists("..\dist\windows-ollama-app-amd64.exe")
+Source: "..\dist\windows-ollama-app-amd64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: not IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
+Source: "..\dist\windows-amd64\vc_redist.x64.exe"; DestDir: "{tmp}"; Check: not IsArm64() and vc_redist_needed(); Flags: deleteafterinstall
+Source: "..\dist\windows-amd64\ollama.exe"; DestDir: "{app}"; Check: not IsArm64(); Flags: ignoreversion 64bit; BeforeInstall: TaskKill('ollama.exe')
+Source: "..\dist\windows-amd64\lib\ollama\*"; DestDir: "{app}\lib\ollama\"; Check: not IsArm64(); Flags: ignoreversion 64bit recursesubdirs
+#endif
+
+; For local development, rely on binary compatibility at runtime since we can't cross compile
+#if FileExists("..\dist\windows-ollama-app-arm64.exe")
+Source: "..\dist\windows-ollama-app-arm64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
+#else 
+Source: "..\dist\windows-ollama-app-amd64.exe"; DestDir: "{app}"; DestName: "{#MyAppExeName}" ;Check: IsArm64();  Flags: ignoreversion 64bit; BeforeInstall: TaskKill('{#MyAppExeName}')
+#endif
+
+#if FileExists("..\dist\windows-arm64\ollama.exe")
+Source: "..\dist\windows-arm64\vc_redist.arm64.exe"; DestDir: "{tmp}"; Check: IsArm64() and vc_redist_needed(); Flags: deleteafterinstall
+Source: "..\dist\windows-arm64\ollama.exe"; DestDir: "{app}"; Check: IsArm64(); Flags: ignoreversion 64bit; BeforeInstall: TaskKill('ollama.exe')
+#endif
+
+Source: ".\assets\app.ico"; DestDir: "{app}"; Flags: ignoreversion
+
+[Icons]
+Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
+Name: "{app}\lib\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
+Name: "{userprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; IconFilename: "{app}\app.ico"
+
+[InstallDelete]
+Type: files; Name: "{%LOCALAPPDATA}\Ollama\updates"
+
+[Run]
+#if DirExists("..\dist\windows-arm64")
+Filename: "{tmp}\vc_redist.arm64.exe"; Parameters: "/install /passive /norestart"; Check: IsArm64() and vc_redist_needed(); StatusMsg: "Installing VC++ Redistributables..."; Flags: waituntilterminated
+#endif
+#if DirExists("..\dist\windows-amd64")
+Filename: "{tmp}\vc_redist.x64.exe"; Parameters: "/install /passive /norestart"; Check: not IsArm64() and vc_redist_needed(); StatusMsg: "Installing VC++ Redistributables..."; Flags: waituntilterminated
+#endif
+Filename: "{cmd}"; Parameters: "/C set PATH={app};%PATH% & ""{app}\{#MyAppExeName}"""; Flags: postinstall nowait runhidden
+
+[UninstallRun]
+; Filename: "{cmd}"; Parameters: "/C ""taskkill /im ''{#MyAppExeName}'' /f /t"; Flags: runhidden
+; Filename: "{cmd}"; Parameters: "/C ""taskkill /im ollama.exe /f /t"; Flags: runhidden
+Filename: "taskkill"; Parameters: "/im ""{#MyAppExeName}"" /f /t"; Flags: runhidden
+Filename: "taskkill"; Parameters: "/im ""ollama.exe"" /f /t"; Flags: runhidden
+; HACK!  need to give the server and app enough time to exit
+; TODO - convert this to a Pascal code script so it waits until they're no longer running, then completes
+Filename: "{cmd}"; Parameters: "/c timeout 5"; Flags: runhidden
+
+[UninstallDelete]
+Type: filesandordirs; Name: "{%TEMP}\ollama*"
+Type: filesandordirs; Name: "{%LOCALAPPDATA}\Ollama"
+Type: filesandordirs; Name: "{%LOCALAPPDATA}\Programs\Ollama"
+Type: filesandordirs; Name: "{%USERPROFILE}\.ollama\history"
+Type: filesandordirs; Name: "{userstartup}\{#MyAppName}.lnk"
+; NOTE: if the user has a custom OLLAMA_MODELS it will be preserved
+
+[InstallDelete]
+Type: filesandordirs; Name: "{%TEMP}\ollama*"
+Type: filesandordirs; Name: "{app}\lib\ollama"
+
+[Messages]
+WizardReady=Ollama
+ReadyLabel1=%nLet's get you up and running with your own large language models.
+SetupAppRunningError=Another Ollama installer is running.%n%nPlease cancel or finish the other installer, then click OK to continue with this install, or Cancel to exit.
+
+
+;FinishedHeadingLabel=Run your first model
+;FinishedLabel=%nRun this command in a PowerShell or cmd terminal.%n%n%n    ollama run llama3.2
+;ClickFinish=%n
+
+[Registry]
+Root: HKCU; Subkey: "Environment"; \
+    ValueType: expandsz; ValueName: "Path"; ValueData: "{olddata};{app}"; \
+    Check: NeedsAddPath('{app}')
+; Register ollama:// URL protocol
+Root: HKCU; Subkey: "Software\Classes\ollama"; ValueType: string; ValueName: ""; ValueData: "URL:Ollama Protocol"; Flags: uninsdeletekey
+Root: HKCU; Subkey: "Software\Classes\ollama"; ValueType: string; ValueName: "URL Protocol"; ValueData: ""; Flags: uninsdeletekey
+Root: HKCU; Subkey: "Software\Classes\ollama\shell\open\command"; ValueType: string; ValueName: ""; ValueData: """{app}\{#MyAppExeName}"" ""%1"""; Flags: uninsdeletekey
+
+[Code]
+
+function NeedsAddPath(Param: string): boolean;
+var
+  OrigPath: string;
+begin
+  if not RegQueryStringValue(HKEY_CURRENT_USER,
+    'Environment',
+    'Path', OrigPath)
+  then begin
+    Result := True;
+    exit;
+  end;
+  { look for the path with leading and trailing semicolon }
+  { Pos() returns 0 if not found }
+  Result := Pos(';' + ExpandConstant(Param) + ';', ';' + OrigPath + ';') = 0;
+end;
+
+{ --- VC Runtime libraries discovery code - Only install vc_redist if it isn't already installed ----- }
+const VCRTL_MIN_V1 = 14;
+const VCRTL_MIN_V2 = 40;
+const VCRTL_MIN_V3 = 33807;
+const VCRTL_MIN_V4 = 0;
+
+ // check if the minimum required vc redist is installed (by looking the registry)
+function vc_redist_needed (): Boolean;
+var
+  sRegKey: string;
+  v1: Cardinal;
+  v2: Cardinal;
+  v3: Cardinal;
+  v4: Cardinal;
+begin
+  if (IsArm64()) then begin
+    sRegKey := 'SOFTWARE\WOW6432Node\Microsoft\VisualStudio\14.0\VC\Runtimes\arm64';
+  end else begin
+    sRegKey := 'SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64';
+  end;
+  if (RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Major', v1)  and
+      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Minor', v2) and
+      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'Bld', v3) and
+      RegQueryDWordValue (HKEY_LOCAL_MACHINE, sRegKey, 'RBld', v4)) then
+  begin
+    Log ('VC Redist version: ' + IntToStr (v1) +
+        '.' + IntToStr (v2) + '.' + IntToStr (v3) +
+        '.' + IntToStr (v4));
+    { Version info was found. Return true if later or equal to our
+       minimal required version RTL_MIN_Vx }
+    Result := not (
+        (v1 > VCRTL_MIN_V1) or ((v1 = VCRTL_MIN_V1) and
+         ((v2 > VCRTL_MIN_V2) or ((v2 = VCRTL_MIN_V2) and
+          ((v3 > VCRTL_MIN_V3) or ((v3 = VCRTL_MIN_V3) and
+           (v4 >= VCRTL_MIN_V4)))))));
+  end
+  else
+    Result := TRUE;
+end;
+
+function GetDirSize(Path: String): Int64;
+var
+  FindRec: TFindRec;
+  FilePath: string;
+  Size: Int64;
+begin
+  if FindFirst(Path + '\*', FindRec) then begin
+    Result := 0;
+    try
+      repeat
+        if (FindRec.Name <> '.') and (FindRec.Name <> '..') then begin
+          FilePath := Path + '\' + FindRec.Name;
+          if (FindRec.Attributes and FILE_ATTRIBUTE_DIRECTORY) <> 0 then begin
+            Size := GetDirSize(FilePath);
+          end else begin
+            Size := Int64(FindRec.SizeHigh) shl 32 + FindRec.SizeLow;
+          end;
+          Result := Result + Size;
+        end;
+      until not FindNext(FindRec);
+    finally
+      FindClose(FindRec);
+    end;
+  end else begin
+    Log(Format('Failed to list %s', [Path]));
+    Result := -1;
+  end;
+end;
+
+var
+  DeleteModelsChecked: Boolean;
+  ModelsDir: string;
+
+procedure InitializeUninstallProgressForm();
+var
+  UninstallPage: TNewNotebookPage;
+  UninstallButton: TNewButton;
+  DeleteModelsCheckbox: TNewCheckBox;
+  OriginalPageNameLabel: string;
+  OriginalPageDescriptionLabel: string;
+  OriginalCancelButtonEnabled: Boolean;
+  OriginalCancelButtonModalResult: Integer;
+  ctrl: TWinControl;
+  ModelDirA: AnsiString;
+  ModelsSize: Int64;
+begin
+  if not UninstallSilent then begin
+    ctrl := UninstallProgressForm.CancelButton;
+    UninstallButton := TNewButton.Create(UninstallProgressForm);
+    UninstallButton.Parent := UninstallProgressForm;
+    UninstallButton.Left := ctrl.Left - ctrl.Width - ScaleX(10);
+    UninstallButton.Top := ctrl.Top;
+    UninstallButton.Width := ctrl.Width;
+    UninstallButton.Height := ctrl.Height;
+    UninstallButton.TabOrder := ctrl.TabOrder;
+    UninstallButton.Caption := 'Uninstall';
+    UninstallButton.ModalResult := mrOK;    
+    UninstallProgressForm.CancelButton.TabOrder := UninstallButton.TabOrder + 1;
+    UninstallPage := TNewNotebookPage.Create(UninstallProgressForm);
+    UninstallPage.Notebook := UninstallProgressForm.InnerNotebook;
+    UninstallPage.Parent := UninstallProgressForm.InnerNotebook;
+    UninstallPage.Align := alClient;
+    UninstallProgressForm.InnerNotebook.ActivePage := UninstallPage;
+
+    ctrl := UninstallProgressForm.StatusLabel;
+    with TNewStaticText.Create(UninstallProgressForm) do begin
+      Parent := UninstallPage;
+      Top := ctrl.Top;
+      Left := ctrl.Left;
+      Width := ctrl.Width;
+      Height := ctrl.Height;
+      AutoSize := False;
+      ShowAccelChar := False;
+      Caption := '';
+    end;
+
+    if (DirExists(GetEnv('USERPROFILE') + '\.ollama\models\blobs')) then begin
+      ModelsDir := GetEnv('USERPROFILE') + '\.ollama\models';
+      ModelsSize := GetDirSize(ModelsDir);
+    end;
+
+    DeleteModelsCheckbox := TNewCheckBox.Create(UninstallProgressForm);
+    DeleteModelsCheckbox.Parent := UninstallPage;
+    DeleteModelsCheckbox.Top := ctrl.Top + ScaleY(30);
+    DeleteModelsCheckbox.Left := ctrl.Left;
+    DeleteModelsCheckbox.Width := ScaleX(300);
+    if ModelsSize > 1024*1024*1024 then begin
+      DeleteModelsCheckbox.Caption := 'Remove models (' + IntToStr(ModelsSize/(1024*1024*1024)) + ' GB) ' + ModelsDir;
+    end else if ModelsSize > 1024*1024 then begin
+      DeleteModelsCheckbox.Caption := 'Remove models (' + IntToStr(ModelsSize/(1024*1024)) + ' MB) ' + ModelsDir;
+    end else begin
+      DeleteModelsCheckbox.Caption := 'Remove models ' + ModelsDir;
+    end;
+    DeleteModelsCheckbox.Checked := True;
+
+    OriginalPageNameLabel := UninstallProgressForm.PageNameLabel.Caption;
+    OriginalPageDescriptionLabel := UninstallProgressForm.PageDescriptionLabel.Caption;
+    OriginalCancelButtonEnabled := UninstallProgressForm.CancelButton.Enabled;
+    OriginalCancelButtonModalResult := UninstallProgressForm.CancelButton.ModalResult;
+
+    UninstallProgressForm.PageNameLabel.Caption := '';
+    UninstallProgressForm.PageDescriptionLabel.Caption := '';
+    UninstallProgressForm.CancelButton.Enabled := True;
+    UninstallProgressForm.CancelButton.ModalResult := mrCancel;
+
+    if UninstallProgressForm.ShowModal = mrCancel then Abort;
+
+    UninstallButton.Visible := False;   
+    UninstallProgressForm.PageNameLabel.Caption := OriginalPageNameLabel;
+    UninstallProgressForm.PageDescriptionLabel.Caption := OriginalPageDescriptionLabel;
+    UninstallProgressForm.CancelButton.Enabled := OriginalCancelButtonEnabled;
+    UninstallProgressForm.CancelButton.ModalResult := OriginalCancelButtonModalResult;
+
+    UninstallProgressForm.InnerNotebook.ActivePage := UninstallProgressForm.InstallingPage;
+
+    if DeleteModelsCheckbox.Checked then begin
+      DeleteModelsChecked:=True;
+    end else begin
+      DeleteModelsChecked:=False;
+    end;
+  end;
+end;
+
+procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
+begin
+  if CurUninstallStep = usDone then begin
+    if DeleteModelsChecked then begin
+      Log('user requested model cleanup');
+      if (VarIsEmpty(ModelsDir)) then begin
+        Log('cleaning up home directory models')
+        DelTree(GetEnv('USERPROFILE') + '\.ollama\models', True, True, True);
+      end else begin
+        Log('cleaning up custom directory models ' + ModelsDir)
+        DelTree(ModelsDir + '\blobs', True, True, True);
+        DelTree(ModelsDir + '\manifests', True, True, True);
+      end;
+    end else begin
+      Log('user requested to preserve model dir');
+    end;
+  end;
+end;
+
+procedure TaskKill(FileName: String);
+var
+  ResultCode: Integer;
+begin
+    Exec('taskkill.exe', '/f /im ' + '"' + FileName + '"', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+end;

app/ollama.rc

@@ -0,0 +1,29 @@
+#include <winver.h>
+
+VS_VERSION_INFO VERSIONINFO
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "Ollama"
+            VALUE "InternalName", "Ollama"
+            VALUE "OriginalFilename", "ollama app.exe"
+            VALUE "ProductName", "Ollama"
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END

app/server/server.go

@@ -0,0 +1,409 @@
+//go:build windows || darwin
+
+package server
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/app/logrotate"
+	"github.com/ollama/ollama/app/store"
+)
+
+const restartDelay = time.Second
+
+// Server is a managed ollama server process
+type Server struct {
+	store *store.Store
+	bin   string // resolved path to `ollama`
+	log   io.WriteCloser
+	dev   bool // true if running with the dev flag
+}
+
+type InferenceCompute struct {
+	Library string
+	Variant string
+	Compute string
+	Driver  string
+	Name    string
+	VRAM    string
+}
+
+type InferenceInfo struct {
+	Computes             []InferenceCompute
+	DefaultContextLength int
+}
+
+func New(s *store.Store, devMode bool) *Server {
+	p := resolvePath("ollama")
+	return &Server{store: s, bin: p, dev: devMode}
+}
+
+func resolvePath(name string) string {
+	// look in the app bundle first
+	if exe, _ := os.Executable(); exe != "" {
+		var dir string
+		if runtime.GOOS == "windows" {
+			dir = filepath.Dir(exe)
+		} else {
+			dir = filepath.Join(filepath.Dir(exe), "..", "Resources")
+		}
+		if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
+			return filepath.Join(dir, name)
+		}
+	}
+
+	// check the development dist path
+	for _, path := range []string{
+		filepath.Join("dist", runtime.GOOS, name),
+		filepath.Join("dist", runtime.GOOS+"-"+runtime.GOARCH, name),
+	} {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+
+	// fallback to system path
+	if p, _ := exec.LookPath(name); p != "" {
+		return p
+	}
+
+	return name
+}
+
+func ollamaServeArgs(args []string) bool {
+	if len(args) < 2 {
+		return false
+	}
+
+	switch strings.Trim(filepath.Base(args[0]), `"`) {
+	case "ollama", "ollama.exe":
+	default:
+		return false
+	}
+
+	for _, rawArg := range args[1:] {
+		arg := strings.Trim(rawArg, `"`)
+		if strings.HasPrefix(arg, "-") {
+			continue
+		}
+
+		return arg == "serve" || arg == "start"
+	}
+
+	return false
+}
+
+// cleanup checks the pid file for a running ollama process
+// and shuts it down gracefully if it is running
+func cleanup() error {
+	data, err := os.ReadFile(pidFile)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	defer os.Remove(pidFile)
+
+	pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
+	if err != nil {
+		return err
+	}
+
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return nil
+	}
+
+	ok, err := terminated(pid)
+	if err != nil {
+		slog.Debug("cleanup: error checking if terminated", "pid", pid, "err", err)
+	}
+	if ok {
+		return nil
+	}
+
+	slog.Info("detected previous ollama process, cleaning up", "pid", pid)
+	return stop(proc)
+}
+
+// stop waits for a process with the provided pid to exit by polling
+// `terminated(pid)`. If the process has not exited within 5 seconds, it logs a
+// warning and kills the process.
+func stop(proc *os.Process) error {
+	if proc == nil {
+		return nil
+	}
+
+	if err := terminate(proc); err != nil {
+		slog.Warn("graceful terminate failed, killing", "err", err)
+		return proc.Kill()
+	}
+
+	deadline := time.NewTimer(5 * time.Second)
+	defer deadline.Stop()
+
+	for {
+		select {
+		case <-deadline.C:
+			slog.Warn("timeout waiting for graceful shutdown; killing", "pid", proc.Pid)
+			return proc.Kill()
+		default:
+			ok, err := terminated(proc.Pid)
+			if err != nil {
+				slog.Error("error checking if ollama process is terminated", "err", err)
+				return err
+			}
+			if ok {
+				return nil
+			}
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+}
+
+func (s *Server) Run(ctx context.Context) error {
+	l, err := openRotatingLog()
+	if err != nil {
+		return err
+	}
+	s.log = l
+	defer s.log.Close()
+
+	if err := cleanup(); err != nil {
+		slog.Warn("failed to cleanup previous ollama process", "err", err)
+	}
+
+	reaped := false
+	for ctx.Err() == nil {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(restartDelay):
+		}
+
+		cmd, err := s.cmd(ctx)
+		if err != nil {
+			return err
+		}
+
+		if err := cmd.Start(); err != nil {
+			return err
+		}
+
+		err = os.WriteFile(pidFile, []byte(strconv.Itoa(cmd.Process.Pid)), 0o644)
+		if err != nil {
+			slog.Warn("failed to write pid file", "file", pidFile, "err", err)
+		}
+
+		if err = cmd.Wait(); err != nil && !errors.Is(err, context.Canceled) {
+			var exitErr *exec.ExitError
+			if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 && !s.dev && !reaped {
+				reaped = true
+				// This could be a port conflict, try to kill any existing ollama processes
+				if err := reapServers(); err != nil {
+					slog.Warn("failed to stop existing ollama server", "err", err)
+				} else {
+					slog.Debug("conflicting server stopped, waiting for port to be released")
+					continue
+				}
+			}
+			slog.Error("ollama exited", "err", err)
+		}
+	}
+	return ctx.Err()
+}
+
+func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
+	settings, err := s.store.Settings()
+	if err != nil {
+		return nil, err
+	}
+
+	cloudDisabled, err := s.store.CloudDisabled()
+	if err != nil {
+		return nil, err
+	}
+
+	cmd := commandContext(ctx, s.bin, "serve")
+	cmd.Stdout, cmd.Stderr = s.log, s.log
+
+	// Copy and mutate the environment to merge in settings the user has specified without dups
+	env := map[string]string{}
+	for _, kv := range os.Environ() {
+		s := strings.SplitN(kv, "=", 2)
+		env[s[0]] = s[1]
+	}
+	if settings.Expose {
+		env["OLLAMA_HOST"] = "0.0.0.0"
+	}
+	if settings.Browser {
+		env["OLLAMA_ORIGINS"] = "*"
+	}
+	if settings.Models != "" {
+		if _, err := os.Stat(settings.Models); err == nil {
+			env["OLLAMA_MODELS"] = settings.Models
+		} else {
+			slog.Warn("models path not accessible, using default", "path", settings.Models, "err", err)
+		}
+	}
+	if settings.ContextLength > 0 {
+		env["OLLAMA_CONTEXT_LENGTH"] = strconv.Itoa(settings.ContextLength)
+	}
+	if cloudDisabled {
+		env["OLLAMA_NO_CLOUD"] = "1"
+	} else {
+		env["OLLAMA_NO_CLOUD"] = "0"
+	}
+	cmd.Env = []string{}
+	for k, v := range env {
+		cmd.Env = append(cmd.Env, k+"="+v)
+	}
+
+	cmd.Cancel = func() error {
+		if cmd.Process == nil {
+			return nil
+		}
+		return stop(cmd.Process)
+	}
+
+	return cmd, nil
+}
+
+func openRotatingLog() (io.WriteCloser, error) {
+	// TODO consider rotation based on size or time, not just every server invocation
+	dir := filepath.Dir(serverLogPath)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, fmt.Errorf("create log directory: %w", err)
+	}
+
+	logrotate.Rotate(serverLogPath)
+	f, err := os.OpenFile(serverLogPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return nil, fmt.Errorf("open log file: %w", err)
+	}
+	return f, nil
+}
+
+// Attempt to retrieve inference compute information from the server
+// log.  Set ctx to timeout to control how long to wait for the logs to appear
+func GetInferenceInfo(ctx context.Context) (*InferenceInfo, error) {
+	info := &InferenceInfo{}
+	computeMarker := regexp.MustCompile(`inference compute.*library=`)
+	defaultCtxMarker := regexp.MustCompile(`vram-based default context`)
+	defaultCtxRegex := regexp.MustCompile(`default_num_ctx=(\d+)`)
+
+	q := `inference compute.*%s=["]([^"]*)["]`
+	nq := `inference compute.*%s=(\S+)\s`
+	type regex struct {
+		q  *regexp.Regexp
+		nq *regexp.Regexp
+	}
+	regexes := map[string]regex{
+		"library": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "library")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "library")),
+		},
+		"variant": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "variant")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "variant")),
+		},
+		"compute": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "compute")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "compute")),
+		},
+		"driver": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "driver")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "driver")),
+		},
+		"name": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "name")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "name")),
+		},
+		"total": {
+			q:  regexp.MustCompile(fmt.Sprintf(q, "total")),
+			nq: regexp.MustCompile(fmt.Sprintf(nq, "total")),
+		},
+	}
+	get := func(field, line string) string {
+		regex, ok := regexes[field]
+		if !ok {
+			slog.Warn("missing field", "field", field)
+			return ""
+		}
+		match := regex.q.FindStringSubmatch(line)
+
+		if len(match) > 1 {
+			return match[1]
+		}
+		match = regex.nq.FindStringSubmatch(line)
+		if len(match) > 1 {
+			return match[1]
+		}
+		return ""
+	}
+	for {
+		select {
+		case <-ctx.Done():
+			return nil, fmt.Errorf("timeout scanning server log for inference compute details")
+		default:
+		}
+		file, err := os.Open(serverLogPath)
+		if err != nil {
+			slog.Debug("failed to open server log", "log", serverLogPath, "error", err)
+			time.Sleep(time.Second)
+			continue
+		}
+		defer file.Close()
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			line := scanner.Text()
+			// Check for inference compute lines
+			if computeMarker.MatchString(line) {
+				ic := InferenceCompute{
+					Library: get("library", line),
+					Variant: get("variant", line),
+					Compute: get("compute", line),
+					Driver:  get("driver", line),
+					Name:    get("name", line),
+					VRAM:    get("total", line),
+				}
+
+				slog.Info("Matched", "inference compute", ic)
+				info.Computes = append(info.Computes, ic)
+				continue
+			}
+			// Check for default context length line
+			if defaultCtxMarker.MatchString(line) {
+				match := defaultCtxRegex.FindStringSubmatch(line)
+				if len(match) > 1 {
+					numCtx, err := strconv.Atoi(match[1])
+					if err == nil {
+						info.DefaultContextLength = numCtx
+						slog.Info("Matched default context length", "default_num_ctx", numCtx)
+					}
+				}
+				return info, nil
+			}
+			// If we've found compute info but hit a non-matching line, return what we have
+			// This handles older server versions that don't log the default context line
+			if len(info.Computes) > 0 {
+				return info, nil
+			}
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}

app/server/server_test.go

@@ -0,0 +1,400 @@
+//go:build windows || darwin
+
+package server
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ollama/ollama/app/store"
+)
+
+func TestNew(t *testing.T) {
+	tmpDir := t.TempDir()
+	st := &store.Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+	defer st.Close() // Ensure database is closed before cleanup
+	s := New(st, false)
+
+	if s == nil {
+		t.Fatal("expected non-nil server")
+	}
+
+	if s.bin == "" {
+		t.Error("expected non-empty bin path")
+	}
+}
+
+func TestServerCmd(t *testing.T) {
+	os.Unsetenv("OLLAMA_HOST")
+	os.Unsetenv("OLLAMA_ORIGINS")
+	os.Unsetenv("OLLAMA_MODELS")
+	var defaultModels string
+	home, err := os.UserHomeDir()
+	if err == nil {
+		defaultModels = filepath.Join(home, ".ollama", "models")
+		os.MkdirAll(defaultModels, 0o755)
+	}
+
+	tmpModels := t.TempDir()
+	tests := []struct {
+		name     string
+		settings store.Settings
+		want     []string
+		dont     []string
+	}{
+		{
+			name:     "default",
+			settings: store.Settings{},
+			want:     []string{"OLLAMA_MODELS=" + defaultModels},
+			dont:     []string{"OLLAMA_HOST=", "OLLAMA_ORIGINS="},
+		},
+		{
+			name:     "expose",
+			settings: store.Settings{Expose: true},
+			want:     []string{"OLLAMA_HOST=0.0.0.0", "OLLAMA_MODELS=" + defaultModels},
+			dont:     []string{"OLLAMA_ORIGINS="},
+		},
+		{
+			name:     "browser",
+			settings: store.Settings{Browser: true},
+			want:     []string{"OLLAMA_ORIGINS=*", "OLLAMA_MODELS=" + defaultModels},
+			dont:     []string{"OLLAMA_HOST="},
+		},
+		{
+			name:     "models",
+			settings: store.Settings{Models: tmpModels},
+			want:     []string{"OLLAMA_MODELS=" + tmpModels},
+			dont:     []string{"OLLAMA_HOST=", "OLLAMA_ORIGINS="},
+		},
+		{
+			name:     "inaccessible_models",
+			settings: store.Settings{Models: "/nonexistent/external/drive/models"},
+			want:     []string{},
+			dont:     []string{"OLLAMA_MODELS="},
+		},
+		{
+			name: "all",
+			settings: store.Settings{
+				Expose:  true,
+				Browser: true,
+				Models:  tmpModels,
+			},
+			want: []string{
+				"OLLAMA_HOST=0.0.0.0",
+				"OLLAMA_ORIGINS=*",
+				"OLLAMA_MODELS=" + tmpModels,
+			},
+			dont: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			st := &store.Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+			defer st.Close() // Ensure database is closed before cleanup
+			st.SetSettings(tt.settings)
+			s := &Server{
+				store: st,
+			}
+
+			cmd, err := s.cmd(t.Context())
+			if err != nil {
+				t.Fatalf("s.cmd() error = %v", err)
+			}
+
+			for _, want := range tt.want {
+				found := false
+				for _, env := range cmd.Env {
+					if strings.HasPrefix(env, want) {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Errorf("expected environment variable containing %s", want)
+				}
+			}
+
+			for _, dont := range tt.dont {
+				for _, env := range cmd.Env {
+					if strings.HasPrefix(env, dont) {
+						t.Errorf("unexpected environment variable: %s", env)
+					}
+				}
+			}
+
+			if cmd.Cancel == nil {
+				t.Error("expected non-nil cancel function")
+			}
+		})
+	}
+}
+
+func TestServerCmdCloudSettingEnv(t *testing.T) {
+	tests := []struct {
+		name          string
+		envValue      string
+		configContent string
+		want          string
+	}{
+		{
+			name: "default cloud enabled",
+			want: "OLLAMA_NO_CLOUD=0",
+		},
+		{
+			name:     "env disables cloud",
+			envValue: "1",
+			want:     "OLLAMA_NO_CLOUD=1",
+		},
+		{
+			name:          "config disables cloud",
+			configContent: `{"disable_ollama_cloud": true}`,
+			want:          "OLLAMA_NO_CLOUD=1",
+		},
+		{
+			name:     "invalid env disables cloud",
+			envValue: "invalid",
+			want:     "OLLAMA_NO_CLOUD=1",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpHome := t.TempDir()
+			t.Setenv("HOME", tmpHome)
+			t.Setenv("USERPROFILE", tmpHome)
+			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
+
+			if tt.configContent != "" {
+				configDir := filepath.Join(tmpHome, ".ollama")
+				if err := os.MkdirAll(configDir, 0o755); err != nil {
+					t.Fatalf("mkdir config dir: %v", err)
+				}
+				configPath := filepath.Join(configDir, "server.json")
+				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
+					t.Fatalf("write config: %v", err)
+				}
+			}
+
+			st := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}
+			defer st.Close()
+
+			s := &Server{store: st}
+			cmd, err := s.cmd(t.Context())
+			if err != nil {
+				t.Fatalf("s.cmd() error = %v", err)
+			}
+
+			found := false
+			for _, env := range cmd.Env {
+				if env == tt.want {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Fatalf("expected environment variable %q in command env", tt.want)
+			}
+		})
+	}
+}
+
+func TestOllamaServeArgs(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want bool
+	}{
+		{
+			name: "system ollama serve",
+			args: []string{"ollama", "serve"},
+			want: true,
+		},
+		{
+			name: "relative path ollama serve",
+			args: []string{"./ollama", "serve"},
+			want: true,
+		},
+		{
+			name: "serve after other flags",
+			args: []string{"./ollama", "--verbose", "serve"},
+			want: true,
+		},
+		{
+			name: "start alias",
+			args: []string{"ollama", "start"},
+			want: true,
+		},
+		{
+			name: "launch command",
+			args: []string{"ollama", "launch", "opencode"},
+			want: false,
+		},
+		{
+			name: "run command with model named serve",
+			args: []string{"ollama", "run", "serve"},
+			want: false,
+		},
+		{
+			name: "launch command with serve in passthrough args",
+			args: []string{"ollama", "launch", "codex", "--", "-p", "serve"},
+			want: false,
+		},
+		{
+			name: "different executable",
+			args: []string{"go", "run", "serve"},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := ollamaServeArgs(tt.args); got != tt.want {
+				t.Fatalf("ollamaServeArgs(%v) = %v, want %v", tt.args, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGetInferenceInfo(t *testing.T) {
+	tests := []struct {
+		name             string
+		log              string
+		expComputes      []InferenceCompute
+		expDefaultCtxLen int
+	}{
+		{
+			name: "metal",
+			log: `time=2025-06-30T09:23:07.374-07:00 level=DEBUG source=sched.go:108 msg="starting llm scheduler"
+time=2025-06-30T09:23:07.416-07:00 level=INFO source=types.go:130 msg="inference compute" id=0 library=metal variant="" compute="" driver=0.0 name="" total="96.0 GiB" available="96.0 GiB"
+time=2025-06-30T09:23:07.417-07:00 level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="96.0 GiB" default_num_ctx=262144
+time=2025-06-30T09:25:56.197-07:00 level=DEBUG source=ggml.go:155 msg="key not found" key=general.alignment default=32
+`,
+			expComputes: []InferenceCompute{{
+				Library: "metal",
+				Driver:  "0.0",
+				VRAM:    "96.0 GiB",
+			}},
+			expDefaultCtxLen: 262144,
+		},
+		{
+			name: "cpu",
+			log: `time=2025-07-01T17:59:51.470Z level=INFO source=gpu.go:377 msg="no compatible GPUs were discovered"
+time=2025-07-01T17:59:51.470Z level=INFO source=types.go:130 msg="inference compute" id=0 library=cpu variant="" compute="" driver=0.0 name="" total="31.3 GiB" available="30.4 GiB"
+time=2025-07-01T17:59:51.471Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="31.3 GiB" default_num_ctx=32768
+[GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
+`,
+			expComputes: []InferenceCompute{{
+				Library: "cpu",
+				Driver:  "0.0",
+				VRAM:    "31.3 GiB",
+			}},
+			expDefaultCtxLen: 32768,
+		},
+		{
+			name: "cuda1",
+			log: `time=2025-07-01T19:33:43.162Z level=DEBUG source=amd_linux.go:419 msg="amdgpu driver not detected /sys/module/amdgpu"
+releasing cuda driver library
+time=2025-07-01T19:33:43.162Z level=INFO source=types.go:130 msg="inference compute" id=GPU-452cac9f-6960-839c-4fb3-0cec83699196 library=cuda variant=v12 compute=6.1 driver=12.7 name="NVIDIA GeForce GT 1030" total="3.9 GiB" available="3.9 GiB"
+time=2025-07-01T19:33:43.163Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="3.9 GiB" default_num_ctx=4096
+[GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
+`,
+			expComputes: []InferenceCompute{{
+				Library: "cuda",
+				Variant: "v12",
+				Compute: "6.1",
+				Driver:  "12.7",
+				Name:    "NVIDIA GeForce GT 1030",
+				VRAM:    "3.9 GiB",
+			}},
+			expDefaultCtxLen: 4096,
+		},
+		{
+			name: "frank",
+			log: `time=2025-07-01T19:36:13.315Z level=INFO source=amd_linux.go:386 msg="amdgpu is supported" gpu=GPU-9abb57639fa80c50 gpu_type=gfx1030
+		releasing cuda driver library
+		time=2025-07-01T19:36:13.315Z level=INFO source=types.go:130 msg="inference compute" id=GPU-d6de3398-9932-6902-11ec-fee8e424c8a2 library=cuda variant=v12 compute=7.5 driver=12.8 name="NVIDIA GeForce RTX 2080 Ti" total="10.6 GiB" available="10.4 GiB"
+		time=2025-07-01T19:36:13.315Z level=INFO source=types.go:130 msg="inference compute" id=GPU-9abb57639fa80c50 library=rocm variant="" compute=gfx1030 driver=6.3 name=1002:73bf total="16.0 GiB" available="1.3 GiB"
+		time=2025-07-01T19:36:13.316Z level=INFO source=routes.go:1721 msg="vram-based default context" total_vram="26.6 GiB" default_num_ctx=32768
+		[GIN] 2025/07/01 - 18:00:09 | 200 |      50.263µs | 100.126.204.152 | HEAD     "/"
+		`,
+			expComputes: []InferenceCompute{
+				{
+					Library: "cuda",
+					Variant: "v12",
+					Compute: "7.5",
+					Driver:  "12.8",
+					Name:    "NVIDIA GeForce RTX 2080 Ti",
+					VRAM:    "10.6 GiB",
+				},
+				{
+					Library: "rocm",
+					Compute: "gfx1030",
+					Driver:  "6.3",
+					Name:    "1002:73bf",
+					VRAM:    "16.0 GiB",
+				},
+			},
+			expDefaultCtxLen: 32768,
+		},
+		{
+			name: "missing_default_context",
+			log: `time=2025-06-30T09:23:07.374-07:00 level=DEBUG source=sched.go:108 msg="starting llm scheduler"
+time=2025-06-30T09:23:07.416-07:00 level=INFO source=types.go:130 msg="inference compute" id=0 library=metal variant="" compute="" driver=0.0 name="" total="96.0 GiB" available="96.0 GiB"
+time=2025-06-30T09:25:56.197-07:00 level=DEBUG source=ggml.go:155 msg="key not found" key=general.alignment default=32
+`,
+			expComputes: []InferenceCompute{{
+				Library: "metal",
+				Driver:  "0.0",
+				VRAM:    "96.0 GiB",
+			}},
+			expDefaultCtxLen: 0, // No default context line, should return 0
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			serverLogPath = filepath.Join(tmpDir, "server.log")
+			err := os.WriteFile(serverLogPath, []byte(tt.log), 0o644)
+			if err != nil {
+				t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
+			}
+			ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
+			defer cancel()
+			info, err := GetInferenceInfo(ctx)
+			if err != nil {
+				t.Fatalf("failed to get inference info: %v", err)
+			}
+			if !reflect.DeepEqual(info.Computes, tt.expComputes) {
+				t.Fatalf("computes mismatch\ngot:\n%#v\nwant:\n%#v", info.Computes, tt.expComputes)
+			}
+			if info.DefaultContextLength != tt.expDefaultCtxLen {
+				t.Fatalf("default context length mismatch: got %d, want %d", info.DefaultContextLength, tt.expDefaultCtxLen)
+			}
+		})
+	}
+}
+
+func TestGetInferenceInfoTimeout(t *testing.T) {
+	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Millisecond)
+	defer cancel()
+	tmpDir := t.TempDir()
+	serverLogPath = filepath.Join(tmpDir, "server.log")
+	err := os.WriteFile(serverLogPath, []byte("foo\nbar\nbaz\n"), 0o644)
+	if err != nil {
+		t.Fatalf("failed to write log file %s: %s", serverLogPath, err)
+	}
+	_, err = GetInferenceInfo(ctx)
+	if err == nil {
+		t.Fatal("expected timeout")
+	}
+	if !strings.Contains(err.Error(), "timeout") {
+		t.Fatalf("unexpected error: %s", err)
+	}
+}

app/server/server_unix.go

@@ -0,0 +1,117 @@
+//go:build darwin
+
+package server
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+var (
+	pidFile       = filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Ollama", "ollama.pid")
+	serverLogPath = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "server.log")
+)
+
+func commandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
+	return exec.CommandContext(ctx, name, arg...)
+}
+
+func terminate(proc *os.Process) error {
+	return proc.Signal(os.Interrupt)
+}
+
+func terminated(pid int) (bool, error) {
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false, fmt.Errorf("failed to find process: %v", err)
+	}
+
+	err = proc.Signal(syscall.Signal(0))
+	if err != nil {
+		if errors.Is(err, os.ErrProcessDone) || errors.Is(err, syscall.ESRCH) {
+			return true, nil
+		}
+
+		return false, fmt.Errorf("error signaling process: %v", err)
+	}
+
+	return false, nil
+}
+
+func ollamaServeProcess(pid int) bool {
+	output, err := exec.Command("ps", "-p", strconv.Itoa(pid), "-o", "args=").Output()
+	if err != nil {
+		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
+		return false
+	}
+
+	return ollamaServeArgs(strings.Fields(strings.TrimSpace(string(output))))
+}
+
+// reapServers kills external ollama serve processes except our own.
+func reapServers() error {
+	// Get our own PID to avoid killing ourselves
+	currentPID := os.Getpid()
+
+	// Use pkill to kill ollama processes
+	// -x matches the whole command name exactly
+	// We'll get the list first, then kill selectively
+	cmd := exec.Command("pgrep", "-x", "ollama")
+	output, err := cmd.Output()
+	if err != nil {
+		// No ollama processes found
+		slog.Debug("no ollama processes found")
+		return nil //nolint:nilerr
+	}
+
+	pidsStr := strings.TrimSpace(string(output))
+	if pidsStr == "" {
+		return nil
+	}
+
+	pids := strings.Split(pidsStr, "\n")
+	for _, pidStr := range pids {
+		pidStr = strings.TrimSpace(pidStr)
+		if pidStr == "" {
+			continue
+		}
+
+		pid, err := strconv.Atoi(pidStr)
+		if err != nil {
+			slog.Debug("failed to parse PID", "pidStr", pidStr, "err", err)
+			continue
+		}
+		if pid == currentPID {
+			continue
+		}
+		if !ollamaServeProcess(pid) {
+			continue
+		}
+
+		proc, err := os.FindProcess(pid)
+		if err != nil {
+			slog.Debug("failed to find process", "pid", pid, "err", err)
+			continue
+		}
+
+		if err := proc.Signal(syscall.SIGTERM); err != nil {
+			// Try SIGKILL if SIGTERM fails
+			if err := proc.Signal(syscall.SIGKILL); err != nil {
+				slog.Warn("failed to stop external ollama process", "pid", pid, "err", err)
+				continue
+			}
+		}
+
+		slog.Info("stopped external ollama process", "pid", pid)
+	}
+
+	return nil
+}

app/server/server_windows.go

@@ -0,0 +1,174 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+var (
+	pidFile       = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "ollama.pid")
+	serverLogPath = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "server.log")
+)
+
+func commandContext(ctx context.Context, name string, arg ...string) *exec.Cmd {
+	cmd := exec.CommandContext(ctx, name, arg...)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    true,
+		CreationFlags: windows.CREATE_NEW_PROCESS_GROUP,
+	}
+
+	return cmd
+}
+
+func terminate(proc *os.Process) error {
+	dll, err := windows.LoadDLL("kernel32.dll")
+	if err != nil {
+		return err
+	}
+	defer dll.Release()
+
+	pid := proc.Pid
+
+	f, err := dll.FindProc("AttachConsole")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err := f.Call(uintptr(pid))
+	if r1 == 0 && err != syscall.ERROR_ACCESS_DENIED {
+		return err
+	}
+
+	f, err = dll.FindProc("SetConsoleCtrlHandler")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err = f.Call(0, 1)
+	if r1 == 0 {
+		return err
+	}
+
+	f, err = dll.FindProc("GenerateConsoleCtrlEvent")
+	if err != nil {
+		return err
+	}
+
+	r1, _, err = f.Call(windows.CTRL_BREAK_EVENT, uintptr(pid))
+	if r1 == 0 {
+		return err
+	}
+
+	r1, _, err = f.Call(windows.CTRL_C_EVENT, uintptr(pid))
+	if r1 == 0 {
+		return err
+	}
+
+	return nil
+}
+
+const STILL_ACTIVE = 259
+
+func terminated(pid int) (bool, error) {
+	hProcess, err := windows.OpenProcess(windows.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		if errno, ok := err.(windows.Errno); ok && errno == windows.ERROR_INVALID_PARAMETER {
+			return true, nil
+		}
+		return false, fmt.Errorf("failed to open process: %v", err)
+	}
+	defer windows.CloseHandle(hProcess)
+
+	var exitCode uint32
+	err = windows.GetExitCodeProcess(hProcess, &exitCode)
+	if err != nil {
+		return false, fmt.Errorf("failed to get exit code: %v", err)
+	}
+
+	if exitCode == STILL_ACTIVE {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func ollamaServeProcess(pid int) bool {
+	cmd := exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "CommandLine", "/value")
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
+	output, err := cmd.Output()
+	if err != nil {
+		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
+		return false
+	}
+
+	for _, line := range strings.Split(string(output), "\n") {
+		line = strings.TrimSpace(line)
+		commandLine, ok := strings.CutPrefix(line, "CommandLine=")
+		if !ok {
+			continue
+		}
+
+		return ollamaServeArgs(strings.Fields(strings.ToLower(commandLine)))
+	}
+
+	return false
+}
+
+// reapServers kills external ollama serve processes except our own.
+func reapServers() error {
+	// Get current process ID to avoid killing ourselves
+	currentPID := os.Getpid()
+
+	// Use wmic to find ollama processes
+	cmd := exec.Command("wmic", "process", "where", "name='ollama.exe'", "get", "ProcessId")
+	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
+	output, err := cmd.Output()
+	if err != nil {
+		// No ollama processes found
+		slog.Debug("no ollama processes found")
+		return nil //nolint:nilerr
+	}
+
+	lines := strings.Split(string(output), "\n")
+	var pids []string
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || line == "ProcessId" {
+			continue
+		}
+
+		if _, err := strconv.Atoi(line); err == nil {
+			pids = append(pids, line)
+		}
+	}
+
+	for _, pidStr := range pids {
+		pid, err := strconv.Atoi(pidStr)
+		if err != nil {
+			continue
+		}
+
+		if pid == currentPID {
+			continue
+		}
+		if !ollamaServeProcess(pid) {
+			continue
+		}
+
+		cmd := exec.Command("taskkill", "/F", "/PID", pidStr)
+		if err := cmd.Run(); err != nil {
+			slog.Warn("failed to kill ollama process", "pid", pid, "err", err)
+		}
+	}
+
+	return nil
+}

app/store/cloud_config.go

@@ -0,0 +1,128 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/ollama/ollama/envconfig"
+)
+
+const serverConfigFilename = "server.json"
+
+type serverConfig struct {
+	DisableOllamaCloud bool `json:"disable_ollama_cloud,omitempty"`
+}
+
+// CloudDisabled returns whether cloud features should be disabled.
+// The source of truth is: OLLAMA_NO_CLOUD OR ~/.ollama/server.json:disable_ollama_cloud.
+func (s *Store) CloudDisabled() (bool, error) {
+	disabled, _, err := s.CloudStatus()
+	return disabled, err
+}
+
+// CloudStatus returns whether cloud is disabled and the source of that decision.
+// Source is one of: "none", "env", "config", "both".
+func (s *Store) CloudStatus() (bool, string, error) {
+	if err := s.ensureDB(); err != nil {
+		return false, "", err
+	}
+
+	configDisabled, err := readServerConfigCloudDisabled()
+	if err != nil {
+		return false, "", err
+	}
+
+	envDisabled := envconfig.NoCloudEnv()
+	return envDisabled || configDisabled, cloudStatusSource(envDisabled, configDisabled), nil
+}
+
+// SetCloudEnabled writes the cloud setting to ~/.ollama/server.json.
+func (s *Store) SetCloudEnabled(enabled bool) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+	return setCloudEnabled(enabled)
+}
+
+func setCloudEnabled(enabled bool) error {
+	configPath, err := serverConfigPath()
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return fmt.Errorf("create server config directory: %w", err)
+	}
+
+	configMap := map[string]any{}
+	if data, err := os.ReadFile(configPath); err == nil {
+		if err := json.Unmarshal(data, &configMap); err != nil {
+			// If the existing file is invalid JSON, overwrite with a fresh object.
+			configMap = map[string]any{}
+		}
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return fmt.Errorf("read server config: %w", err)
+	}
+
+	configMap["disable_ollama_cloud"] = !enabled
+
+	data, err := json.MarshalIndent(configMap, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshal server config: %w", err)
+	}
+	data = append(data, '\n')
+
+	if err := os.WriteFile(configPath, data, 0o644); err != nil {
+		return fmt.Errorf("write server config: %w", err)
+	}
+
+	return nil
+}
+
+func readServerConfigCloudDisabled() (bool, error) {
+	configPath, err := serverConfigPath()
+	if err != nil {
+		return false, err
+	}
+
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return false, nil
+		}
+		return false, fmt.Errorf("read server config: %w", err)
+	}
+
+	var cfg serverConfig
+	// Invalid or unexpected JSON should not block startup; treat as default.
+	if json.Unmarshal(data, &cfg) == nil {
+		return cfg.DisableOllamaCloud, nil
+	}
+	return false, nil
+}
+
+func serverConfigPath() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("resolve home directory: %w", err)
+	}
+	return filepath.Join(home, ".ollama", serverConfigFilename), nil
+}
+
+func cloudStatusSource(envDisabled bool, configDisabled bool) string {
+	switch {
+	case envDisabled && configDisabled:
+		return "both"
+	case envDisabled:
+		return "env"
+	case configDisabled:
+		return "config"
+	default:
+		return "none"
+	}
+}

app/store/cloud_config_test.go

@@ -0,0 +1,130 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCloudDisabled(t *testing.T) {
+	tests := []struct {
+		name          string
+		envValue      string
+		configContent string
+		wantDisabled  bool
+		wantSource    string
+	}{
+		{
+			name:         "default enabled",
+			wantDisabled: false,
+			wantSource:   "none",
+		},
+		{
+			name:         "env disables cloud",
+			envValue:     "1",
+			wantDisabled: true,
+			wantSource:   "env",
+		},
+		{
+			name:          "config disables cloud",
+			configContent: `{"disable_ollama_cloud": true}`,
+			wantDisabled:  true,
+			wantSource:    "config",
+		},
+		{
+			name:          "env and config",
+			envValue:      "1",
+			configContent: `{"disable_ollama_cloud": false}`,
+			wantDisabled:  true,
+			wantSource:    "env",
+		},
+		{
+			name:          "invalid config is ignored",
+			configContent: `{bad`,
+			wantDisabled:  false,
+			wantSource:    "none",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpHome := t.TempDir()
+			setTestHome(t, tmpHome)
+			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
+
+			if tt.configContent != "" {
+				configDir := filepath.Join(tmpHome, ".ollama")
+				if err := os.MkdirAll(configDir, 0o755); err != nil {
+					t.Fatalf("mkdir config dir: %v", err)
+				}
+				configPath := filepath.Join(configDir, serverConfigFilename)
+				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
+					t.Fatalf("write config: %v", err)
+				}
+			}
+
+			s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
+			defer s.Close()
+
+			disabled, err := s.CloudDisabled()
+			if err != nil {
+				t.Fatalf("CloudDisabled() error = %v", err)
+			}
+			if disabled != tt.wantDisabled {
+				t.Fatalf("CloudDisabled() = %v, want %v", disabled, tt.wantDisabled)
+			}
+
+			statusDisabled, source, err := s.CloudStatus()
+			if err != nil {
+				t.Fatalf("CloudStatus() error = %v", err)
+			}
+			if statusDisabled != tt.wantDisabled {
+				t.Fatalf("CloudStatus() disabled = %v, want %v", statusDisabled, tt.wantDisabled)
+			}
+			if source != tt.wantSource {
+				t.Fatalf("CloudStatus() source = %v, want %v", source, tt.wantSource)
+			}
+		})
+	}
+}
+
+func TestSetCloudEnabled(t *testing.T) {
+	tmpHome := t.TempDir()
+	setTestHome(t, tmpHome)
+
+	configDir := filepath.Join(tmpHome, ".ollama")
+	if err := os.MkdirAll(configDir, 0o755); err != nil {
+		t.Fatalf("mkdir config dir: %v", err)
+	}
+	configPath := filepath.Join(configDir, serverConfigFilename)
+	if err := os.WriteFile(configPath, []byte(`{"another_key":"value","disable_ollama_cloud":true}`), 0o644); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+
+	s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
+	defer s.Close()
+
+	if err := s.SetCloudEnabled(true); err != nil {
+		t.Fatalf("SetCloudEnabled(true) error = %v", err)
+	}
+
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatalf("read config: %v", err)
+	}
+
+	var got map[string]any
+	if err := json.Unmarshal(data, &got); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+
+	if got["disable_ollama_cloud"] != false {
+		t.Fatalf("disable_ollama_cloud = %v, want false", got["disable_ollama_cloud"])
+	}
+	if got["another_key"] != "value" {
+		t.Fatalf("another_key = %v, want value", got["another_key"])
+	}
+}

app/store/database_test.go

@@ -0,0 +1,483 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestSchemaMigrations(t *testing.T) {
+	t.Run("schema comparison after migration", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		migratedDBPath := filepath.Join(tmpDir, "migrated.db")
+		migratedDB := loadV2Schema(t, migratedDBPath)
+		defer migratedDB.Close()
+
+		if err := migratedDB.migrate(); err != nil {
+			t.Fatalf("migration failed: %v", err)
+		}
+
+		// Create fresh database with current schema
+		freshDBPath := filepath.Join(tmpDir, "fresh.db")
+		freshDB, err := newDatabase(freshDBPath)
+		if err != nil {
+			t.Fatalf("failed to create fresh database: %v", err)
+		}
+		defer freshDB.Close()
+
+		// Extract tables and indexes from both databases, directly comparing their schemas won't work due to ordering
+		migratedSchema := schemaMap(migratedDB)
+		freshSchema := schemaMap(freshDB)
+
+		if !cmp.Equal(migratedSchema, freshSchema) {
+			t.Errorf("Schema difference found:\n%s", cmp.Diff(freshSchema, migratedSchema))
+		}
+
+		// Verify both databases have the same final schema version
+		migratedVersion, _ := migratedDB.getSchemaVersion()
+		freshVersion, _ := freshDB.getSchemaVersion()
+		if migratedVersion != freshVersion {
+			t.Errorf("schema version mismatch: migrated=%d, fresh=%d", migratedVersion, freshVersion)
+		}
+	})
+
+	t.Run("idempotent migrations", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		dbPath := filepath.Join(tmpDir, "test.db")
+		db := loadV2Schema(t, dbPath)
+		defer db.Close()
+
+		// Run migration twice
+		if err := db.migrate(); err != nil {
+			t.Fatalf("first migration failed: %v", err)
+		}
+
+		if err := db.migrate(); err != nil {
+			t.Fatalf("second migration failed: %v", err)
+		}
+
+		// Verify schema version is still correct
+		version, err := db.getSchemaVersion()
+		if err != nil {
+			t.Fatalf("failed to get schema version: %v", err)
+		}
+		if version != currentSchemaVersion {
+			t.Errorf("expected schema version %d after double migration, got %d", currentSchemaVersion, version)
+		}
+	})
+
+	t.Run("init database has correct schema version", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		dbPath := filepath.Join(tmpDir, "test.db")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// Get the schema version from the newly initialized database
+		version, err := db.getSchemaVersion()
+		if err != nil {
+			t.Fatalf("failed to get schema version: %v", err)
+		}
+
+		// Verify it matches the currentSchemaVersion constant
+		if version != currentSchemaVersion {
+			t.Errorf("expected schema version %d in initialized database, got %d", currentSchemaVersion, version)
+		}
+	})
+}
+
+func TestMigrationV13ToV14ContextLength(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := newDatabase(dbPath)
+	if err != nil {
+		t.Fatalf("failed to create database: %v", err)
+	}
+	defer db.Close()
+
+	_, err = db.conn.Exec("UPDATE settings SET context_length = 4096, schema_version = 13")
+	if err != nil {
+		t.Fatalf("failed to seed v13 settings row: %v", err)
+	}
+
+	if err := db.migrate(); err != nil {
+		t.Fatalf("migration from v13 to v14 failed: %v", err)
+	}
+
+	var contextLength int
+	if err := db.conn.QueryRow("SELECT context_length FROM settings").Scan(&contextLength); err != nil {
+		t.Fatalf("failed to read context_length: %v", err)
+	}
+
+	if contextLength != 0 {
+		t.Fatalf("expected context_length to migrate to 0, got %d", contextLength)
+	}
+
+	version, err := db.getSchemaVersion()
+	if err != nil {
+		t.Fatalf("failed to get schema version: %v", err)
+	}
+	if version != currentSchemaVersion {
+		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
+	}
+}
+
+func TestMigrationV15ToV16LastHomeViewDefaultsToLaunch(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := newDatabase(dbPath)
+	if err != nil {
+		t.Fatalf("failed to create database: %v", err)
+	}
+	defer db.Close()
+
+	if _, err := db.conn.Exec(`
+		ALTER TABLE settings DROP COLUMN last_home_view;
+		UPDATE settings SET schema_version = 15;
+	`); err != nil {
+		t.Fatalf("failed to seed v15 settings row: %v", err)
+	}
+
+	if err := db.migrate(); err != nil {
+		t.Fatalf("migration from v15 to v16 failed: %v", err)
+	}
+
+	var lastHomeView string
+	if err := db.conn.QueryRow("SELECT last_home_view FROM settings").Scan(&lastHomeView); err != nil {
+		t.Fatalf("failed to read last_home_view: %v", err)
+	}
+
+	if lastHomeView != "launch" {
+		t.Fatalf("expected last_home_view to default to launch after migration, got %q", lastHomeView)
+	}
+
+	version, err := db.getSchemaVersion()
+	if err != nil {
+		t.Fatalf("failed to get schema version: %v", err)
+	}
+	if version != currentSchemaVersion {
+		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
+	}
+}
+
+func TestChatDeletionWithCascade(t *testing.T) {
+	t.Run("chat deletion cascades to related messages", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		dbPath := filepath.Join(tmpDir, "test.db")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// Create test chat
+		testChatID := "test-chat-cascade-123"
+		testChat := Chat{
+			ID:        testChatID,
+			Title:     "Test Chat for Cascade Delete",
+			CreatedAt: time.Now(),
+			Messages: []Message{
+				{
+					Role:      "user",
+					Content:   "Hello, this is a test message",
+					CreatedAt: time.Now(),
+					UpdatedAt: time.Now(),
+				},
+				{
+					Role:      "assistant",
+					Content:   "Hi there! This is a response.",
+					CreatedAt: time.Now(),
+					UpdatedAt: time.Now(),
+				},
+			},
+		}
+
+		// Save the chat with messages
+		if err := db.saveChat(testChat); err != nil {
+			t.Fatalf("failed to save test chat: %v", err)
+		}
+
+		// Verify chat and messages exist
+		chatCount := countRows(t, db, "chats")
+		messageCount := countRows(t, db, "messages")
+
+		if chatCount != 1 {
+			t.Errorf("expected 1 chat, got %d", chatCount)
+		}
+		if messageCount != 2 {
+			t.Errorf("expected 2 messages, got %d", messageCount)
+		}
+
+		// Verify specific chat exists
+		var exists bool
+		err = db.conn.QueryRow("SELECT EXISTS(SELECT 1 FROM chats WHERE id = ?)", testChatID).Scan(&exists)
+		if err != nil {
+			t.Fatalf("failed to check chat existence: %v", err)
+		}
+		if !exists {
+			t.Error("test chat should exist before deletion")
+		}
+
+		// Verify messages exist for this chat
+		messageCountForChat := countRowsWithCondition(t, db, "messages", "chat_id = ?", testChatID)
+		if messageCountForChat != 2 {
+			t.Errorf("expected 2 messages for test chat, got %d", messageCountForChat)
+		}
+
+		// Delete the chat
+		if err := db.deleteChat(testChatID); err != nil {
+			t.Fatalf("failed to delete chat: %v", err)
+		}
+
+		// Verify chat is deleted
+		chatCountAfter := countRows(t, db, "chats")
+		if chatCountAfter != 0 {
+			t.Errorf("expected 0 chats after deletion, got %d", chatCountAfter)
+		}
+
+		// Verify messages are CASCADE deleted
+		messageCountAfter := countRows(t, db, "messages")
+		if messageCountAfter != 0 {
+			t.Errorf("expected 0 messages after CASCADE deletion, got %d", messageCountAfter)
+		}
+
+		// Verify specific chat no longer exists
+		err = db.conn.QueryRow("SELECT EXISTS(SELECT 1 FROM chats WHERE id = ?)", testChatID).Scan(&exists)
+		if err != nil {
+			t.Fatalf("failed to check chat existence after deletion: %v", err)
+		}
+		if exists {
+			t.Error("test chat should not exist after deletion")
+		}
+
+		// Verify no orphaned messages remain
+		orphanedCount := countRowsWithCondition(t, db, "messages", "chat_id = ?", testChatID)
+		if orphanedCount != 0 {
+			t.Errorf("expected 0 orphaned messages, got %d", orphanedCount)
+		}
+	})
+
+	t.Run("foreign keys are enabled", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		dbPath := filepath.Join(tmpDir, "test.db")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// Verify foreign keys are enabled
+		var foreignKeysEnabled int
+		err = db.conn.QueryRow("PRAGMA foreign_keys").Scan(&foreignKeysEnabled)
+		if err != nil {
+			t.Fatalf("failed to check foreign keys: %v", err)
+		}
+		if foreignKeysEnabled != 1 {
+			t.Errorf("expected foreign keys to be enabled (1), got %d", foreignKeysEnabled)
+		}
+	})
+
+	// This test is only relevant for v8 migrations, but we keep it here for now
+	// since it's a useful test to ensure that we don't introduce any new orphaned data
+	t.Run("cleanup orphaned data", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		dbPath := filepath.Join(tmpDir, "test.db")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// First disable foreign keys to simulate the bug from ollama/ollama#11785
+		_, err = db.conn.Exec("PRAGMA foreign_keys = OFF")
+		if err != nil {
+			t.Fatalf("failed to disable foreign keys: %v", err)
+		}
+
+		// Create a chat and message
+		testChatID := "orphaned-test-chat"
+		testMessageID := int64(999)
+
+		_, err = db.conn.Exec("INSERT INTO chats (id, title) VALUES (?, ?)", testChatID, "Orphaned Test Chat")
+		if err != nil {
+			t.Fatalf("failed to insert test chat: %v", err)
+		}
+
+		_, err = db.conn.Exec("INSERT INTO messages (id, chat_id, role, content) VALUES (?, ?, ?, ?)",
+			testMessageID, testChatID, "user", "test message")
+		if err != nil {
+			t.Fatalf("failed to insert test message: %v", err)
+		}
+
+		// Delete chat but keep message (simulating the bug from ollama/ollama#11785)
+		_, err = db.conn.Exec("DELETE FROM chats WHERE id = ?", testChatID)
+		if err != nil {
+			t.Fatalf("failed to delete chat: %v", err)
+		}
+
+		// Verify we have orphaned message
+		orphanedCount := countRowsWithCondition(t, db, "messages", "chat_id = ?", testChatID)
+		if orphanedCount != 1 {
+			t.Errorf("expected 1 orphaned message, got %d", orphanedCount)
+		}
+
+		// Run cleanup
+		if err := db.cleanupOrphanedData(); err != nil {
+			t.Fatalf("failed to cleanup orphaned data: %v", err)
+		}
+
+		// Verify orphaned message is gone
+		orphanedCountAfter := countRowsWithCondition(t, db, "messages", "chat_id = ?", testChatID)
+		if orphanedCountAfter != 0 {
+			t.Errorf("expected 0 orphaned messages after cleanup, got %d", orphanedCountAfter)
+		}
+	})
+}
+
+func countRows(t *testing.T, db *database, table string) int {
+	t.Helper()
+	var count int
+	err := db.conn.QueryRow(fmt.Sprintf("SELECT COUNT(*) FROM %s", table)).Scan(&count)
+	if err != nil {
+		t.Fatalf("failed to count rows in %s: %v", table, err)
+	}
+	return count
+}
+
+func countRowsWithCondition(t *testing.T, db *database, table, condition string, args ...interface{}) int {
+	t.Helper()
+	var count int
+	query := fmt.Sprintf("SELECT COUNT(*) FROM %s WHERE %s", table, condition)
+	err := db.conn.QueryRow(query, args...).Scan(&count)
+	if err != nil {
+		t.Fatalf("failed to count rows with condition: %v", err)
+	}
+	return count
+}
+
+// Test helpers for schema migration testing
+
+// schemaMap returns both tables/columns and indexes (ignoring order)
+func schemaMap(db *database) map[string]interface{} {
+	result := make(map[string]any)
+
+	result["tables"] = columnMap(db)
+	result["indexes"] = indexMap(db)
+
+	return result
+}
+
+// columnMap returns a map of table names to their column sets (ignoring order)
+func columnMap(db *database) map[string][]string {
+	result := make(map[string][]string)
+
+	// Get all table names
+	tableQuery := `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+	rows, _ := db.conn.Query(tableQuery)
+	defer rows.Close()
+
+	for rows.Next() {
+		var tableName string
+		rows.Scan(&tableName)
+
+		// Get columns for this table
+		colQuery := fmt.Sprintf("PRAGMA table_info(%s)", tableName)
+		colRows, _ := db.conn.Query(colQuery)
+
+		var columns []string
+		for colRows.Next() {
+			var cid int
+			var name, dataType sql.NullString
+			var notNull, primaryKey int
+			var defaultValue sql.NullString
+
+			colRows.Scan(&cid, &name, &dataType, &notNull, &defaultValue, &primaryKey)
+
+			// Create a normalized column description
+			colDesc := fmt.Sprintf("%s %s", name.String, dataType.String)
+			if notNull == 1 {
+				colDesc += " NOT NULL"
+			}
+			if defaultValue.Valid && defaultValue.String != "" {
+				// Skip DEFAULT for schema_version as it doesn't get updated during migrations
+				if name.String != "schema_version" {
+					colDesc += " DEFAULT " + defaultValue.String
+				}
+			}
+			if primaryKey == 1 {
+				colDesc += " PRIMARY KEY"
+			}
+
+			columns = append(columns, colDesc)
+		}
+		colRows.Close()
+
+		// Sort columns to ignore order differences
+		sort.Strings(columns)
+		result[tableName] = columns
+	}
+
+	return result
+}
+
+// indexMap returns a map of index names to their definitions
+func indexMap(db *database) map[string]string {
+	result := make(map[string]string)
+
+	// Get all indexes (excluding auto-created primary key indexes)
+	indexQuery := `SELECT name, sql FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%' AND sql IS NOT NULL ORDER BY name`
+	rows, _ := db.conn.Query(indexQuery)
+	defer rows.Close()
+
+	for rows.Next() {
+		var name, sql string
+		rows.Scan(&name, &sql)
+
+		// Normalize the SQL by removing extra whitespace
+		sql = strings.Join(strings.Fields(sql), " ")
+		result[name] = sql
+	}
+
+	return result
+}
+
+// loadV2Schema loads the version 2 schema from testdata/schema.sql
+func loadV2Schema(t *testing.T, dbPath string) *database {
+	t.Helper()
+
+	// Read the v1 schema file
+	schemaFile := filepath.Join("testdata", "schema.sql")
+	schemaSQL, err := os.ReadFile(schemaFile)
+	if err != nil {
+		t.Fatalf("failed to read schema file: %v", err)
+	}
+
+	// Open database connection
+	conn, err := sql.Open("sqlite3", dbPath+"?_foreign_keys=on&_journal_mode=WAL&_busy_timeout=5000&_txlock=immediate")
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+
+	// Execute the v1 schema
+	_, err = conn.Exec(string(schemaSQL))
+	if err != nil {
+		conn.Close()
+		t.Fatalf("failed to execute v1 schema: %v", err)
+	}
+
+	return &database{conn: conn}
+}

app/store/image.go

@@ -0,0 +1,128 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type Image struct {
+	Filename string `json:"filename"`
+	Path     string `json:"path"`
+	Size     int64  `json:"size,omitempty"`
+	MimeType string `json:"mime_type,omitempty"`
+}
+
+// Bytes loads image data from disk for a given ImageData reference
+func (i *Image) Bytes() ([]byte, error) {
+	return ImgBytes(i.Path)
+}
+
+// ImgBytes reads image data from the specified file path
+func ImgBytes(path string) ([]byte, error) {
+	if path == "" {
+		return nil, fmt.Errorf("empty image path")
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read image file %s: %w", path, err)
+	}
+
+	return data, nil
+}
+
+// ImgDir returns the directory path for storing images for a specific chat
+func (s *Store) ImgDir() string {
+	dbPath := s.DBPath
+	if dbPath == "" {
+		dbPath = defaultDBPath
+	}
+	storeDir := filepath.Dir(dbPath)
+	return filepath.Join(storeDir, "cache", "images")
+}
+
+// ImgToFile saves image data to disk and returns ImageData reference
+func (s *Store) ImgToFile(chatID string, imageBytes []byte, filename, mimeType string) (Image, error) {
+	baseImageDir := s.ImgDir()
+	if err := os.MkdirAll(baseImageDir, 0o755); err != nil {
+		return Image{}, fmt.Errorf("create base image directory: %w", err)
+	}
+
+	// Root prevents path traversal issues
+	root, err := os.OpenRoot(baseImageDir)
+	if err != nil {
+		return Image{}, fmt.Errorf("open image root directory: %w", err)
+	}
+	defer root.Close()
+
+	// Create chat-specific subdirectory within the root
+	chatDir := sanitize(chatID)
+	if err := root.Mkdir(chatDir, 0o755); err != nil && !os.IsExist(err) {
+		return Image{}, fmt.Errorf("create chat directory: %w", err)
+	}
+
+	// Generate a unique filename to avoid conflicts
+	// Use hash of content + original filename for uniqueness
+	hash := sha256.Sum256(imageBytes)
+	hashStr := hex.EncodeToString(hash[:])[:16] // Use first 16 chars of hash
+
+	// Extract file extension from original filename or mime type
+	ext := filepath.Ext(filename)
+	if ext == "" {
+		switch mimeType {
+		case "image/jpeg":
+			ext = ".jpg"
+		case "image/png":
+			ext = ".png"
+		case "image/webp":
+			ext = ".webp"
+		default:
+			ext = ".img"
+		}
+	}
+
+	// Create unique filename: hash + original name + extension
+	baseFilename := sanitize(strings.TrimSuffix(filename, ext))
+	uniqueFilename := fmt.Sprintf("%s_%s%s", hashStr, baseFilename, ext)
+	relativePath := filepath.Join(chatDir, uniqueFilename)
+	file, err := root.Create(relativePath)
+	if err != nil {
+		return Image{}, fmt.Errorf("create image file: %w", err)
+	}
+	defer file.Close()
+
+	if _, err := file.Write(imageBytes); err != nil {
+		return Image{}, fmt.Errorf("write image data: %w", err)
+	}
+
+	return Image{
+		Filename: uniqueFilename,
+		Path:     filepath.Join(baseImageDir, relativePath),
+		Size:     int64(len(imageBytes)),
+		MimeType: mimeType,
+	}, nil
+}
+
+// sanitize removes unsafe characters from filenames
+func sanitize(filename string) string {
+	// Convert to safe characters only
+	safe := strings.Map(func(r rune) rune {
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-' {
+			return r
+		}
+		return '_'
+	}, filename)
+
+	// Clean up and validate
+	safe = strings.Trim(safe, "_")
+	if safe == "" {
+		return "image"
+	}
+	return safe
+}

app/store/migration_test.go

@@ -0,0 +1,290 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"database/sql"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestConfigMigration(t *testing.T) {
+	tmpDir := t.TempDir()
+	// Create a legacy config.json
+	legacyConfig := legacyData{
+		ID:           "test-device-id-12345",
+		FirstTimeRun: true, // In old system, true meant "has completed first run"
+	}
+
+	configData, err := json.MarshalIndent(legacyConfig, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	configPath := filepath.Join(tmpDir, "config.json")
+	if err := os.WriteFile(configPath, configData, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Override the legacy config path for testing
+	oldLegacyConfigPath := legacyConfigPath
+	legacyConfigPath = configPath
+	defer func() { legacyConfigPath = oldLegacyConfigPath }()
+
+	// Create store with database in same directory
+	s := Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+	defer s.Close()
+
+	// First access should trigger migration
+	id, err := s.ID()
+	if err != nil {
+		t.Fatalf("failed to get ID: %v", err)
+	}
+
+	if id != "test-device-id-12345" {
+		t.Errorf("expected migrated ID 'test-device-id-12345', got '%s'", id)
+	}
+
+	// Check HasCompletedFirstRun
+	hasCompleted, err := s.HasCompletedFirstRun()
+	if err != nil {
+		t.Fatalf("failed to get has completed first run: %v", err)
+	}
+
+	if !hasCompleted {
+		t.Error("expected has completed first run to be true after migration")
+	}
+
+	// Verify migration is marked as complete
+	migrated, err := s.db.isConfigMigrated()
+	if err != nil {
+		t.Fatalf("failed to check migration status: %v", err)
+	}
+
+	if !migrated {
+		t.Error("expected config to be marked as migrated")
+	}
+
+	// Create a new store instance to verify migration doesn't run again
+	s2 := Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+	defer s2.Close()
+
+	// Delete the config file to ensure we're not reading from it
+	os.Remove(configPath)
+
+	// Verify data is still there
+	id2, err := s2.ID()
+	if err != nil {
+		t.Fatalf("failed to get ID from second store: %v", err)
+	}
+
+	if id2 != "test-device-id-12345" {
+		t.Errorf("expected persisted ID 'test-device-id-12345', got '%s'", id2)
+	}
+}
+
+func TestNoConfigToMigrate(t *testing.T) {
+	tmpDir := t.TempDir()
+	// Override the legacy config path for testing
+	oldLegacyConfigPath := legacyConfigPath
+	legacyConfigPath = filepath.Join(tmpDir, "config.json")
+	defer func() { legacyConfigPath = oldLegacyConfigPath }()
+
+	// Create store without any config.json
+	s := Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+	defer s.Close()
+
+	// Should generate a new ID
+	id, err := s.ID()
+	if err != nil {
+		t.Fatalf("failed to get ID: %v", err)
+	}
+
+	if id == "" {
+		t.Error("expected auto-generated ID, got empty string")
+	}
+
+	// HasCompletedFirstRun should be false (default)
+	hasCompleted, err := s.HasCompletedFirstRun()
+	if err != nil {
+		t.Fatalf("failed to get has completed first run: %v", err)
+	}
+
+	if hasCompleted {
+		t.Error("expected has completed first run to be false by default")
+	}
+
+	// Migration should still be marked as complete
+	migrated, err := s.db.isConfigMigrated()
+	if err != nil {
+		t.Fatalf("failed to check migration status: %v", err)
+	}
+
+	if !migrated {
+		t.Error("expected config to be marked as migrated even with no config.json")
+	}
+}
+
+func TestCloudMigrationFromAirplaneMode(t *testing.T) {
+	tmpHome := t.TempDir()
+	setTestHome(t, tmpHome)
+	t.Setenv("OLLAMA_NO_CLOUD", "")
+
+	dbPath := filepath.Join(tmpHome, "db.sqlite")
+	db, err := newDatabase(dbPath)
+	if err != nil {
+		t.Fatalf("failed to create database: %v", err)
+	}
+
+	if _, err := db.conn.Exec("UPDATE settings SET airplane_mode = 1, cloud_setting_migrated = 0"); err != nil {
+		db.Close()
+		t.Fatalf("failed to seed airplane migration state: %v", err)
+	}
+	db.Close()
+
+	s := Store{DBPath: dbPath}
+	defer s.Close()
+
+	// Trigger DB initialization + one-time cloud migration.
+	if _, err := s.ID(); err != nil {
+		t.Fatalf("failed to initialize store: %v", err)
+	}
+
+	disabled, err := s.CloudDisabled()
+	if err != nil {
+		t.Fatalf("CloudDisabled() error: %v", err)
+	}
+	if !disabled {
+		t.Fatal("expected cloud to be disabled after migrating airplane_mode=true")
+	}
+
+	configPath := filepath.Join(tmpHome, ".ollama", serverConfigFilename)
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatalf("failed to read migrated server config: %v", err)
+	}
+
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("failed to parse migrated server config: %v", err)
+	}
+	if cfg["disable_ollama_cloud"] != true {
+		t.Fatalf("disable_ollama_cloud = %v, want true", cfg["disable_ollama_cloud"])
+	}
+
+	var airplaneMode, migrated bool
+	if err := s.db.conn.QueryRow("SELECT airplane_mode, cloud_setting_migrated FROM settings").Scan(&airplaneMode, &migrated); err != nil {
+		t.Fatalf("failed to read migration flags from DB: %v", err)
+	}
+	if !airplaneMode {
+		t.Fatal("expected legacy airplane_mode value to remain unchanged")
+	}
+	if !migrated {
+		t.Fatal("expected cloud_setting_migrated to be true")
+	}
+}
+
+const (
+	v1Schema = `
+	CREATE TABLE IF NOT EXISTS settings (
+		id INTEGER PRIMARY KEY CHECK (id = 1),
+		device_id TEXT NOT NULL DEFAULT '',
+		has_completed_first_run BOOLEAN NOT NULL DEFAULT 0,
+		expose BOOLEAN NOT NULL DEFAULT 0,
+		browser BOOLEAN NOT NULL DEFAULT 0,
+		models TEXT NOT NULL DEFAULT '',
+		remote TEXT NOT NULL DEFAULT '',
+		agent BOOLEAN NOT NULL DEFAULT 0,
+		tools BOOLEAN NOT NULL DEFAULT 0,
+		working_dir TEXT NOT NULL DEFAULT '',
+		window_width INTEGER NOT NULL DEFAULT 0,
+		window_height INTEGER NOT NULL DEFAULT 0,
+		config_migrated BOOLEAN NOT NULL DEFAULT 0,
+		schema_version INTEGER NOT NULL DEFAULT 1
+	);
+
+	-- Insert default settings row if it doesn't exist
+	INSERT OR IGNORE INTO settings (id) VALUES (1);
+
+	CREATE TABLE IF NOT EXISTS chats (
+		id TEXT PRIMARY KEY,
+		title TEXT NOT NULL DEFAULT '',
+		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+	);
+
+	CREATE TABLE IF NOT EXISTS messages (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		chat_id TEXT NOT NULL,
+		role TEXT NOT NULL,
+		content TEXT NOT NULL DEFAULT '',
+		thinking TEXT NOT NULL DEFAULT '',
+		stream BOOLEAN NOT NULL DEFAULT 0,
+		model_name TEXT,
+		model_cloud BOOLEAN,
+		model_ollama_host BOOLEAN,
+		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+		updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+		thinking_time_start TIMESTAMP,
+		thinking_time_end TIMESTAMP,
+		FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
+	);
+
+	CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id);
+
+	CREATE TABLE IF NOT EXISTS tool_calls (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		message_id INTEGER NOT NULL,
+		type TEXT NOT NULL,
+		function_name TEXT NOT NULL,
+		function_arguments TEXT NOT NULL,
+		function_result TEXT,
+		FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+	);
+
+	CREATE INDEX IF NOT EXISTS idx_tool_calls_message_id ON tool_calls(message_id);
+	`
+)
+
+func TestMigrationFromEpoc(t *testing.T) {
+	tmpDir := t.TempDir()
+	s := Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+	defer s.Close()
+	// Open database connection
+	conn, err := sql.Open("sqlite3", s.DBPath+"?_foreign_keys=on&_journal_mode=WAL")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Test the connection
+	if err := conn.Ping(); err != nil {
+		conn.Close()
+		t.Fatal(err)
+	}
+	s.db = &database{conn: conn}
+	t.Logf("DB created: %s", s.DBPath)
+	_, err = s.db.conn.Exec(v1Schema)
+	if err != nil {
+		t.Fatal(err)
+	}
+	version, err := s.db.getSchemaVersion()
+	if err != nil {
+		t.Fatalf("failed to get schema version: %v", err)
+	}
+	if version != 1 {
+		t.Fatalf("expected: %d\n got: %d", 1, version)
+	}
+
+	t.Logf("v1 schema created")
+	if err := s.db.migrate(); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("migrations completed")
+	version, err = s.db.getSchemaVersion()
+	if err != nil {
+		t.Fatalf("failed to get schema version: %v", err)
+	}
+	if version != currentSchemaVersion {
+		t.Fatalf("expected: %d\n got: %d", currentSchemaVersion, version)
+	}
+}

app/store/schema.sql

@@ -0,0 +1,61 @@
+-- This is the version 2 schema for the app database, the first released schema to users.
+-- Do not modify this file. It is used to test that the database schema stays in a consistent state between schema migrations.
+
+CREATE TABLE IF NOT EXISTS settings (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    device_id TEXT NOT NULL DEFAULT '',
+    has_completed_first_run BOOLEAN NOT NULL DEFAULT 0,
+    expose BOOLEAN NOT NULL DEFAULT 0,
+    survey BOOLEAN NOT NULL DEFAULT TRUE,
+    browser BOOLEAN NOT NULL DEFAULT 0,
+    models TEXT NOT NULL DEFAULT '',
+    remote TEXT NOT NULL DEFAULT '',
+    agent BOOLEAN NOT NULL DEFAULT 0,
+    tools BOOLEAN NOT NULL DEFAULT 0,
+    working_dir TEXT NOT NULL DEFAULT '',
+    context_length INTEGER NOT NULL DEFAULT 4096,
+    window_width INTEGER NOT NULL DEFAULT 0,
+    window_height INTEGER NOT NULL DEFAULT 0,
+    config_migrated BOOLEAN NOT NULL DEFAULT 0,
+    schema_version INTEGER NOT NULL DEFAULT 2
+);
+
+-- Insert default settings row if it doesn't exist
+INSERT OR IGNORE INTO settings (id) VALUES (1);
+
+CREATE TABLE IF NOT EXISTS chats (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    chat_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL DEFAULT '',
+    thinking TEXT NOT NULL DEFAULT '',
+    stream BOOLEAN NOT NULL DEFAULT 0,
+    model_name TEXT,
+    model_cloud BOOLEAN,
+    model_ollama_host BOOLEAN,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    thinking_time_start TIMESTAMP,
+    thinking_time_end TIMESTAMP,
+    FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    function_name TEXT NOT NULL,
+    function_arguments TEXT NOT NULL,
+    function_result TEXT,
+    FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_tool_calls_message_id ON tool_calls(message_id);

app/store/schema_test.go

@@ -0,0 +1,60 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestSchemaVersioning(t *testing.T) {
+	tmpDir := t.TempDir()
+	// Override legacy config path to avoid migration logs
+	oldLegacyConfigPath := legacyConfigPath
+	legacyConfigPath = filepath.Join(tmpDir, "config.json")
+	defer func() { legacyConfigPath = oldLegacyConfigPath }()
+
+	t.Run("new database has correct schema version", func(t *testing.T) {
+		dbPath := filepath.Join(tmpDir, "new_db.sqlite")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// Check schema version
+		version, err := db.getSchemaVersion()
+		if err != nil {
+			t.Fatalf("failed to get schema version: %v", err)
+		}
+
+		if version != currentSchemaVersion {
+			t.Errorf("expected schema version %d, got %d", currentSchemaVersion, version)
+		}
+	})
+
+	t.Run("can update schema version", func(t *testing.T) {
+		dbPath := filepath.Join(tmpDir, "update_db.sqlite")
+		db, err := newDatabase(dbPath)
+		if err != nil {
+			t.Fatalf("failed to create database: %v", err)
+		}
+		defer db.Close()
+
+		// Set a different version
+		testVersion := 42
+		if err := db.setSchemaVersion(testVersion); err != nil {
+			t.Fatalf("failed to set schema version: %v", err)
+		}
+
+		// Verify it was updated
+		version, err := db.getSchemaVersion()
+		if err != nil {
+			t.Fatalf("failed to get schema version: %v", err)
+		}
+
+		if version != testVersion {
+			t.Errorf("expected schema version %d, got %d", testVersion, version)
+		}
+	})
+}

app/store/store.go

@@ -0,0 +1,536 @@
+//go:build windows || darwin
+
+// Package store provides a simple JSON file store for the desktop application
+// to save and load data such as ollama server configuration, messages,
+// login information and more.
+package store
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/ollama/ollama/app/types/not"
+)
+
+type File struct {
+	Filename string `json:"filename"`
+	Data     []byte `json:"data"`
+}
+
+type User struct {
+	Name     string    `json:"name"`
+	Email    string    `json:"email"`
+	Plan     string    `json:"plan"`
+	CachedAt time.Time `json:"cachedAt"`
+}
+
+type Message struct {
+	Role              string           `json:"role"`
+	Content           string           `json:"content"`
+	Thinking          string           `json:"thinking"`
+	Stream            bool             `json:"stream"`
+	Model             string           `json:"model,omitempty"`
+	Attachments       []File           `json:"attachments,omitempty"`
+	ToolCalls         []ToolCall       `json:"tool_calls,omitempty"`
+	ToolCall          *ToolCall        `json:"tool_call,omitempty"`
+	ToolName          string           `json:"tool_name,omitempty"`
+	ToolResult        *json.RawMessage `json:"tool_result,omitempty"`
+	CreatedAt         time.Time        `json:"created_at"`
+	UpdatedAt         time.Time        `json:"updated_at"`
+	ThinkingTimeStart *time.Time       `json:"thinkingTimeStart,omitempty" ts_type:"Date | undefined" ts_transform:"__VALUE__ && new Date(__VALUE__)"`
+	ThinkingTimeEnd   *time.Time       `json:"thinkingTimeEnd,omitempty" ts_type:"Date | undefined" ts_transform:"__VALUE__ && new Date(__VALUE__)"`
+}
+
+// MessageOptions contains optional parameters for creating a Message
+type MessageOptions struct {
+	Model             string
+	Attachments       []File
+	Stream            bool
+	Thinking          string
+	ToolCalls         []ToolCall
+	ToolCall          *ToolCall
+	ToolResult        *json.RawMessage
+	ThinkingTimeStart *time.Time
+	ThinkingTimeEnd   *time.Time
+}
+
+// NewMessage creates a new Message with the given options
+func NewMessage(role, content string, opts *MessageOptions) Message {
+	now := time.Now()
+	msg := Message{
+		Role:      role,
+		Content:   content,
+		CreatedAt: now,
+		UpdatedAt: now,
+	}
+
+	if opts != nil {
+		msg.Model = opts.Model
+		msg.Attachments = opts.Attachments
+		msg.Stream = opts.Stream
+		msg.Thinking = opts.Thinking
+		msg.ToolCalls = opts.ToolCalls
+		msg.ToolCall = opts.ToolCall
+		msg.ToolResult = opts.ToolResult
+		msg.ThinkingTimeStart = opts.ThinkingTimeStart
+		msg.ThinkingTimeEnd = opts.ThinkingTimeEnd
+	}
+
+	return msg
+}
+
+type ToolCall struct {
+	Type     string       `json:"type"`
+	Function ToolFunction `json:"function"`
+}
+
+type ToolFunction struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"`
+	Result    any    `json:"result,omitempty"`
+}
+
+type Model struct {
+	Model      string     `json:"model"`                 // Model name
+	Digest     string     `json:"digest,omitempty"`      // Model digest from the registry
+	ModifiedAt *time.Time `json:"modified_at,omitempty"` // When the model was last modified locally
+}
+
+type Chat struct {
+	ID           string          `json:"id"`
+	Messages     []Message       `json:"messages"`
+	Title        string          `json:"title"`
+	CreatedAt    time.Time       `json:"created_at"`
+	BrowserState json.RawMessage `json:"browser_state,omitempty" ts_type:"BrowserStateData"`
+}
+
+// NewChat creates a new Chat with the ID, with CreatedAt timestamp initialized
+func NewChat(id string) *Chat {
+	return &Chat{
+		ID:        id,
+		Messages:  []Message{},
+		CreatedAt: time.Now(),
+	}
+}
+
+type Settings struct {
+	// Expose is a boolean that indicates if the ollama server should
+	// be exposed to the network
+	Expose bool
+
+	// Browser is a boolean that indicates if the ollama server should
+	// be exposed to browser windows (e.g. CORS set to allow all origins)
+	Browser bool
+
+	// Survey is a boolean that indicates if the user allows anonymous
+	// inference information to be shared with Ollama
+	Survey bool
+
+	// Models is a string that contains the models to load on startup
+	Models string
+
+	// TODO(parthsareen): temporary for experimentation
+	// Agent indicates if the app should use multi-turn tools to fulfill user requests
+	Agent bool
+
+	// Tools indicates if the app should use single-turn tools to fulfill user requests
+	Tools bool
+
+	// WorkingDir specifies the working directory for all agent operations
+	WorkingDir string
+
+	// ContextLength specifies the context length for the ollama server (using OLLAMA_CONTEXT_LENGTH)
+	ContextLength int
+
+	// TurboEnabled indicates if Ollama Turbo features are enabled
+	TurboEnabled bool
+
+	// Maps gpt-oss specific frontend name' BrowserToolEnabled' to db field 'websearch_enabled'
+	WebSearchEnabled bool
+
+	// ThinkEnabled indicates if thinking is enabled
+	ThinkEnabled bool
+
+	// ThinkLevel indicates the level of thinking to use for models that support multiple levels
+	ThinkLevel string
+
+	// SelectedModel stores the last model that the user selected
+	SelectedModel string
+
+	// SidebarOpen indicates if the chat sidebar is open
+	SidebarOpen bool
+
+	// LastHomeView stores the preferred home route target ("chat" or integration name)
+	LastHomeView string
+
+	// AutoUpdateEnabled indicates if automatic updates should be downloaded
+	AutoUpdateEnabled bool
+}
+
+type Store struct {
+	// DBPath allows overriding the default database path (mainly for testing)
+	DBPath string
+
+	// dbMu protects database initialization only
+	dbMu sync.Mutex
+	db   *database
+}
+
+var defaultDBPath = func() string {
+	switch runtime.GOOS {
+	case "windows":
+		return filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "db.sqlite")
+	case "darwin":
+		return filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Ollama", "db.sqlite")
+	default:
+		return filepath.Join(os.Getenv("HOME"), ".ollama", "db.sqlite")
+	}
+}()
+
+// legacyConfigPath is the path to the old config.json file
+var legacyConfigPath = func() string {
+	switch runtime.GOOS {
+	case "windows":
+		return filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "config.json")
+	case "darwin":
+		return filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Ollama", "config.json")
+	default:
+		return filepath.Join(os.Getenv("HOME"), ".ollama", "config.json")
+	}
+}()
+
+// legacyData represents the old config.json structure (only fields we need to migrate)
+type legacyData struct {
+	ID           string `json:"id"`
+	FirstTimeRun bool   `json:"first-time-run"`
+}
+
+func (s *Store) ensureDB() error {
+	// Fast path: check if db is already initialized
+	if s.db != nil {
+		return nil
+	}
+
+	// Slow path: initialize database with lock
+	s.dbMu.Lock()
+	defer s.dbMu.Unlock()
+
+	// Double-check after acquiring lock
+	if s.db != nil {
+		return nil
+	}
+
+	dbPath := s.DBPath
+	if dbPath == "" {
+		dbPath = defaultDBPath
+	}
+
+	// Ensure directory exists
+	if err := os.MkdirAll(filepath.Dir(dbPath), 0o755); err != nil {
+		return fmt.Errorf("create db directory: %w", err)
+	}
+
+	database, err := newDatabase(dbPath)
+	if err != nil {
+		return fmt.Errorf("open database: %w", err)
+	}
+
+	// Generate device ID if needed
+	id, err := database.getID()
+	if err != nil || id == "" {
+		// Generate new UUID for device
+		u, err := uuid.NewV7()
+		if err == nil {
+			database.setID(u.String())
+		}
+	}
+
+	s.db = database
+
+	// Check if we need to migrate from config.json
+	migrated, err := database.isConfigMigrated()
+	if err != nil || !migrated {
+		if err := s.migrateFromConfig(database); err != nil {
+			slog.Warn("failed to migrate from config.json", "error", err)
+		}
+	}
+
+	// Run one-time migration from legacy airplane_mode behavior.
+	if err := s.migrateCloudSetting(database); err != nil {
+		return fmt.Errorf("migrate cloud setting: %w", err)
+	}
+
+	return nil
+}
+
+// migrateCloudSetting migrates legacy airplane_mode into server.json exactly once.
+// After this, cloud state is sourced from server.json OR OLLAMA_NO_CLOUD.
+func (s *Store) migrateCloudSetting(database *database) error {
+	migrated, err := database.isCloudSettingMigrated()
+	if err != nil {
+		return err
+	}
+	if migrated {
+		return nil
+	}
+
+	airplaneMode, err := database.getAirplaneMode()
+	if err != nil {
+		return err
+	}
+
+	if airplaneMode {
+		if err := setCloudEnabled(false); err != nil {
+			return fmt.Errorf("migrate airplane_mode to cloud disabled: %w", err)
+		}
+	}
+
+	if err := database.setCloudSettingMigrated(true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// migrateFromConfig attempts to migrate ID and FirstTimeRun from config.json
+func (s *Store) migrateFromConfig(database *database) error {
+	configPath := legacyConfigPath
+
+	// Check if config.json exists
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		// No config to migrate, mark as migrated
+		return database.setConfigMigrated(true)
+	}
+
+	// Read the config file
+	b, err := os.ReadFile(configPath)
+	if err != nil {
+		return fmt.Errorf("read legacy config: %w", err)
+	}
+
+	var legacy legacyData
+	if err := json.Unmarshal(b, &legacy); err != nil {
+		// If we can't parse it, just mark as migrated and move on
+		slog.Warn("failed to parse legacy config.json", "error", err)
+		return database.setConfigMigrated(true)
+	}
+
+	// Migrate the ID if present
+	if legacy.ID != "" {
+		if err := database.setID(legacy.ID); err != nil {
+			return fmt.Errorf("migrate device ID: %w", err)
+		}
+		slog.Info("migrated device ID from config.json")
+	}
+
+	hasCompleted := legacy.FirstTimeRun // If old FirstTimeRun is true, it means first run was completed
+	if err := database.setHasCompletedFirstRun(hasCompleted); err != nil {
+		return fmt.Errorf("migrate first time run: %w", err)
+	}
+	slog.Info("migrated first run status from config.json", "hasCompleted", hasCompleted)
+
+	// Mark as migrated
+	if err := database.setConfigMigrated(true); err != nil {
+		return fmt.Errorf("mark config as migrated: %w", err)
+	}
+
+	slog.Info("successfully migrated settings from config.json")
+	return nil
+}
+
+func (s *Store) ID() (string, error) {
+	if err := s.ensureDB(); err != nil {
+		return "", err
+	}
+
+	return s.db.getID()
+}
+
+func (s *Store) HasCompletedFirstRun() (bool, error) {
+	if err := s.ensureDB(); err != nil {
+		return false, err
+	}
+
+	return s.db.getHasCompletedFirstRun()
+}
+
+func (s *Store) SetHasCompletedFirstRun(hasCompleted bool) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.setHasCompletedFirstRun(hasCompleted)
+}
+
+func (s *Store) Settings() (Settings, error) {
+	if err := s.ensureDB(); err != nil {
+		return Settings{}, fmt.Errorf("load settings: %w", err)
+	}
+
+	settings, err := s.db.getSettings()
+	if err != nil {
+		return Settings{}, err
+	}
+
+	// Set default models directory if not set
+	if settings.Models == "" {
+		dir := os.Getenv("OLLAMA_MODELS")
+		if dir != "" {
+			settings.Models = dir
+		} else {
+			home, err := os.UserHomeDir()
+			if err == nil {
+				settings.Models = filepath.Join(home, ".ollama", "models")
+			}
+		}
+	}
+
+	if settings.LastHomeView == "" {
+		settings.LastHomeView = "launch"
+	}
+
+	return settings, nil
+}
+
+func (s *Store) SetSettings(settings Settings) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.setSettings(settings)
+}
+
+func (s *Store) Chats() ([]Chat, error) {
+	if err := s.ensureDB(); err != nil {
+		return nil, err
+	}
+
+	return s.db.getAllChats()
+}
+
+func (s *Store) Chat(id string) (*Chat, error) {
+	return s.ChatWithOptions(id, true)
+}
+
+func (s *Store) ChatWithOptions(id string, loadAttachmentData bool) (*Chat, error) {
+	if err := s.ensureDB(); err != nil {
+		return nil, err
+	}
+
+	chat, err := s.db.getChatWithOptions(id, loadAttachmentData)
+	if err != nil {
+		return nil, fmt.Errorf("%w: chat %s", not.Found, id)
+	}
+
+	return chat, nil
+}
+
+func (s *Store) SetChat(chat Chat) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.saveChat(chat)
+}
+
+func (s *Store) DeleteChat(id string) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	// Delete from database
+	if err := s.db.deleteChat(id); err != nil {
+		return fmt.Errorf("%w: chat %s", not.Found, id)
+	}
+
+	// Also delete associated images
+	chatImgDir := filepath.Join(s.ImgDir(), id)
+	if err := os.RemoveAll(chatImgDir); err != nil {
+		// Log error but don't fail the deletion
+		slog.Warn("failed to delete chat images", "chat_id", id, "error", err)
+	}
+
+	return nil
+}
+
+func (s *Store) WindowSize() (int, int, error) {
+	if err := s.ensureDB(); err != nil {
+		return 0, 0, err
+	}
+
+	return s.db.getWindowSize()
+}
+
+func (s *Store) SetWindowSize(width, height int) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.setWindowSize(width, height)
+}
+
+func (s *Store) UpdateLastMessage(chatID string, message Message) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.updateLastMessage(chatID, message)
+}
+
+func (s *Store) AppendMessage(chatID string, message Message) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.appendMessage(chatID, message)
+}
+
+func (s *Store) UpdateChatBrowserState(chatID string, state json.RawMessage) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.updateChatBrowserState(chatID, state)
+}
+
+func (s *Store) User() (*User, error) {
+	if err := s.ensureDB(); err != nil {
+		return nil, err
+	}
+
+	return s.db.getUser()
+}
+
+func (s *Store) SetUser(user User) error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	user.CachedAt = time.Now()
+	return s.db.setUser(user)
+}
+
+func (s *Store) ClearUser() error {
+	if err := s.ensureDB(); err != nil {
+		return err
+	}
+
+	return s.db.clearUser()
+}
+
+func (s *Store) Close() error {
+	s.dbMu.Lock()
+	defer s.dbMu.Unlock()
+
+	if s.db != nil {
+		return s.db.Close()
+	}
+	return nil
+}

app/store/store_test.go

@@ -0,0 +1,248 @@
+//go:build windows || darwin
+
+package store
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestStore(t *testing.T) {
+	s, cleanup := setupTestStore(t)
+	defer cleanup()
+
+	t.Run("default id", func(t *testing.T) {
+		// ID should be automatically generated
+		id, err := s.ID()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if id == "" {
+			t.Error("expected non-empty ID")
+		}
+
+		// Verify ID is persisted
+		id2, err := s.ID()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if id != id2 {
+			t.Errorf("expected ID %s, got %s", id, id2)
+		}
+	})
+
+	t.Run("has completed first run", func(t *testing.T) {
+		// Default should be false (hasn't completed first run yet)
+		hasCompleted, err := s.HasCompletedFirstRun()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if hasCompleted {
+			t.Error("expected has completed first run to be false by default")
+		}
+
+		if err := s.SetHasCompletedFirstRun(true); err != nil {
+			t.Fatal(err)
+		}
+
+		hasCompleted, err = s.HasCompletedFirstRun()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !hasCompleted {
+			t.Error("expected has completed first run to be true")
+		}
+	})
+
+	t.Run("settings", func(t *testing.T) {
+		sc := Settings{
+			Expose:     true,
+			Browser:    true,
+			Survey:     true,
+			Models:     "/tmp/models",
+			Agent:      true,
+			Tools:      false,
+			WorkingDir: "/tmp/work",
+		}
+
+		if err := s.SetSettings(sc); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Compare fields individually since Models might get a default
+		if loaded.Expose != sc.Expose || loaded.Browser != sc.Browser ||
+			loaded.Agent != sc.Agent || loaded.Survey != sc.Survey ||
+			loaded.Tools != sc.Tools || loaded.WorkingDir != sc.WorkingDir {
+			t.Errorf("expected %v, got %v", sc, loaded)
+		}
+	})
+
+	t.Run("settings default home view is launch", func(t *testing.T) {
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "launch" {
+			t.Fatalf("expected default LastHomeView to be launch, got %q", loaded.LastHomeView)
+		}
+	})
+
+	t.Run("settings empty home view falls back to launch", func(t *testing.T) {
+		if err := s.SetSettings(Settings{LastHomeView: ""}); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "launch" {
+			t.Fatalf("expected empty LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
+		}
+	})
+
+	t.Run("settings disabled home view falls back to launch", func(t *testing.T) {
+		if err := s.SetSettings(Settings{LastHomeView: "claude-desktop"}); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "launch" {
+			t.Fatalf("expected disabled LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
+		}
+	})
+
+	t.Run("settings codex app home view is accepted", func(t *testing.T) {
+		if err := s.SetSettings(Settings{LastHomeView: "codex-app"}); err != nil {
+			t.Fatal(err)
+		}
+
+		loaded, err := s.Settings()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if loaded.LastHomeView != "codex-app" {
+			t.Fatalf("expected codex-app LastHomeView to be preserved, got %q", loaded.LastHomeView)
+		}
+	})
+
+	t.Run("window size", func(t *testing.T) {
+		if err := s.SetWindowSize(1024, 768); err != nil {
+			t.Fatal(err)
+		}
+
+		width, height, err := s.WindowSize()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if width != 1024 || height != 768 {
+			t.Errorf("expected 1024x768, got %dx%d", width, height)
+		}
+	})
+
+	t.Run("create and retrieve chat", func(t *testing.T) {
+		chat := NewChat("test-chat-1")
+		chat.Title = "Test Chat"
+
+		chat.Messages = append(chat.Messages, NewMessage("user", "Hello", nil))
+		chat.Messages = append(chat.Messages, NewMessage("assistant", "Hi there!", &MessageOptions{
+			Model: "llama4",
+		}))
+
+		if err := s.SetChat(*chat); err != nil {
+			t.Fatalf("failed to save chat: %v", err)
+		}
+
+		retrieved, err := s.Chat("test-chat-1")
+		if err != nil {
+			t.Fatalf("failed to retrieve chat: %v", err)
+		}
+
+		if retrieved.ID != chat.ID {
+			t.Errorf("expected ID %s, got %s", chat.ID, retrieved.ID)
+		}
+		if retrieved.Title != chat.Title {
+			t.Errorf("expected title %s, got %s", chat.Title, retrieved.Title)
+		}
+		if len(retrieved.Messages) != 2 {
+			t.Fatalf("expected 2 messages, got %d", len(retrieved.Messages))
+		}
+		if retrieved.Messages[0].Content != "Hello" {
+			t.Errorf("expected first message 'Hello', got %s", retrieved.Messages[0].Content)
+		}
+		if retrieved.Messages[1].Content != "Hi there!" {
+			t.Errorf("expected second message 'Hi there!', got %s", retrieved.Messages[1].Content)
+		}
+	})
+
+	t.Run("list chats", func(t *testing.T) {
+		chat2 := NewChat("test-chat-2")
+		chat2.Title = "Another Chat"
+		chat2.Messages = append(chat2.Messages, NewMessage("user", "Test", nil))
+
+		if err := s.SetChat(*chat2); err != nil {
+			t.Fatalf("failed to save chat: %v", err)
+		}
+
+		chats, err := s.Chats()
+		if err != nil {
+			t.Fatalf("failed to list chats: %v", err)
+		}
+
+		if len(chats) != 2 {
+			t.Fatalf("expected 2 chats, got %d", len(chats))
+		}
+	})
+
+	t.Run("delete chat", func(t *testing.T) {
+		if err := s.DeleteChat("test-chat-1"); err != nil {
+			t.Fatalf("failed to delete chat: %v", err)
+		}
+
+		// Verify it's gone
+		_, err := s.Chat("test-chat-1")
+		if err == nil {
+			t.Error("expected error retrieving deleted chat")
+		}
+
+		// Verify other chat still exists
+		chats, err := s.Chats()
+		if err != nil {
+			t.Fatalf("failed to list chats: %v", err)
+		}
+		if len(chats) != 1 {
+			t.Fatalf("expected 1 chat after deletion, got %d", len(chats))
+		}
+	})
+}
+
+// setupTestStore creates a temporary store for testing
+func setupTestStore(t *testing.T) (*Store, func()) {
+	t.Helper()
+
+	tmpDir := t.TempDir()
+
+	// Override legacy config path to ensure no migration happens
+	oldLegacyConfigPath := legacyConfigPath
+	legacyConfigPath = filepath.Join(tmpDir, "config.json")
+
+	s := &Store{DBPath: filepath.Join(tmpDir, "db.sqlite")}
+
+	cleanup := func() {
+		s.Close()
+		legacyConfigPath = oldLegacyConfigPath
+	}
+
+	return s, cleanup
+}

app/store/test_home_test.go

@@ -0,0 +1,11 @@
+//go:build windows || darwin
+
+package store
+
+import "testing"
+
+func setTestHome(t *testing.T, home string) {
+	t.Helper()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+}

app/store/testdata/schema.sql

@@ -0,0 +1,61 @@
+-- This is the version 2 schema for the app database, the first released schema to users.
+-- Do not modify this file. It is used to test that the database schema stays in a consistent state between schema migrations.
+
+CREATE TABLE IF NOT EXISTS settings (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    device_id TEXT NOT NULL DEFAULT '',
+    has_completed_first_run BOOLEAN NOT NULL DEFAULT 0,
+    expose BOOLEAN NOT NULL DEFAULT 0,
+    survey BOOLEAN NOT NULL DEFAULT TRUE,
+    browser BOOLEAN NOT NULL DEFAULT 0,
+    models TEXT NOT NULL DEFAULT '',
+    remote TEXT NOT NULL DEFAULT '',
+    agent BOOLEAN NOT NULL DEFAULT 0,
+    tools BOOLEAN NOT NULL DEFAULT 0,
+    working_dir TEXT NOT NULL DEFAULT '',
+    context_length INTEGER NOT NULL DEFAULT 0,
+    window_width INTEGER NOT NULL DEFAULT 0,
+    window_height INTEGER NOT NULL DEFAULT 0,
+    config_migrated BOOLEAN NOT NULL DEFAULT 0,
+    schema_version INTEGER NOT NULL DEFAULT 2
+);
+
+-- Insert default settings row if it doesn't exist
+INSERT OR IGNORE INTO settings (id) VALUES (1);
+
+CREATE TABLE IF NOT EXISTS chats (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    chat_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL DEFAULT '',
+    thinking TEXT NOT NULL DEFAULT '',
+    stream BOOLEAN NOT NULL DEFAULT 0,
+    model_name TEXT,
+    model_cloud BOOLEAN,
+    model_ollama_host BOOLEAN,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    thinking_time_start TIMESTAMP,
+    thinking_time_end TIMESTAMP,
+    FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    function_name TEXT NOT NULL,
+    function_arguments TEXT NOT NULL,
+    function_result TEXT,
+    FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_tool_calls_message_id ON tool_calls(message_id);

app/tools/browser.go

@@ -0,0 +1,863 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/ollama/ollama/app/ui/responses"
+)
+
+type PageType string
+
+const (
+	PageTypeSearchResults PageType = "initial_results"
+	PageTypeWebpage       PageType = "webpage"
+)
+
+// DefaultViewTokens is the number of tokens to show to the model used when calling displayPage
+const DefaultViewTokens = 1024
+
+/*
+The Browser tool provides web browsing capability for gpt-oss.
+The model uses the tool by usually doing a search first and then choosing to either open a page,
+find a term in a page, or do another search.
+
+The tool optionally may open a URL directly - especially if one is passed in.
+
+Each action is saved into an append-only page stack `responses.BrowserStateData` to keep
+track of the history of the browsing session.
+
+Each `Execute()` for a tool returns the full current state of the browser. ui.go manages the
+browser state representation between the tool, ui, and db.
+
+A new Browser object is created per request - the state is reconstructed by ui.go.
+The initialization of the browser will receive a `responses.BrowserStateData` with the stitched history.
+*/
+
+// BrowserState manages the browsing session on a per-chat basis
+type BrowserState struct {
+	mu   sync.RWMutex
+	Data *responses.BrowserStateData
+}
+type Browser struct {
+	state *BrowserState
+}
+
+// State is only accessed in a single thread, as each chat has its own browser state
+func (b *Browser) State() *responses.BrowserStateData {
+	b.state.mu.RLock()
+	defer b.state.mu.RUnlock()
+	return b.state.Data
+}
+
+func (b *Browser) savePage(page *responses.Page) {
+	b.state.Data.URLToPage[page.URL] = page
+	b.state.Data.PageStack = append(b.state.Data.PageStack, page.URL)
+}
+
+func (b *Browser) getPageFromStack(url string) (*responses.Page, error) {
+	page, ok := b.state.Data.URLToPage[url]
+	if !ok {
+		return nil, fmt.Errorf("page not found for url %s", url)
+	}
+	return page, nil
+}
+
+func NewBrowser(state *responses.BrowserStateData) *Browser {
+	if state == nil {
+		state = &responses.BrowserStateData{
+			PageStack:  []string{},
+			ViewTokens: DefaultViewTokens,
+			URLToPage:  make(map[string]*responses.Page),
+		}
+	}
+	b := &BrowserState{
+		Data: state,
+	}
+
+	return &Browser{
+		state: b,
+	}
+}
+
+type BrowserSearch struct {
+	Browser
+	webSearch *BrowserWebSearch
+}
+
+// NewBrowserSearch creates a new browser search instance
+func NewBrowserSearch(bb *Browser) *BrowserSearch {
+	if bb == nil {
+		bb = &Browser{
+			state: &BrowserState{
+				Data: &responses.BrowserStateData{
+					PageStack:  []string{},
+					ViewTokens: DefaultViewTokens,
+					URLToPage:  make(map[string]*responses.Page),
+				},
+			},
+		}
+	}
+	return &BrowserSearch{
+		Browser:   *bb,
+		webSearch: &BrowserWebSearch{},
+	}
+}
+
+func (b *BrowserSearch) Name() string {
+	return "browser.search"
+}
+
+func (b *BrowserSearch) Description() string {
+	return "Search the web for information"
+}
+
+func (b *BrowserSearch) Prompt() string {
+	return ""
+}
+
+func (b *BrowserSearch) Schema() map[string]any {
+	return map[string]any{}
+}
+
+func (b *BrowserSearch) Execute(ctx context.Context, args map[string]any) (any, string, error) {
+	query, ok := args["query"].(string)
+	if !ok {
+		return nil, "", fmt.Errorf("query parameter is required")
+	}
+
+	topn, ok := args["topn"].(int)
+	if !ok {
+		topn = 5
+	}
+
+	searchArgs := map[string]any{
+		"queries":     []any{query},
+		"max_results": topn,
+	}
+
+	result, err := b.webSearch.Execute(ctx, searchArgs)
+	if err != nil {
+		return nil, "", fmt.Errorf("search error: %w", err)
+	}
+
+	searchResponse, ok := result.(*WebSearchResponse)
+	if !ok {
+		return nil, "", fmt.Errorf("invalid search results format")
+	}
+
+	// Build main search results page that contains all search results
+	searchResultsPage := b.buildSearchResultsPageCollection(query, searchResponse)
+	b.savePage(searchResultsPage)
+	cursor := len(b.state.Data.PageStack) - 1
+	// cache result for each page
+	for _, queryResults := range searchResponse.Results {
+		for i, result := range queryResults {
+			resultPage := b.buildSearchResultsPage(&result, i+1)
+			// save to global only, do not add to visited stack
+			b.state.Data.URLToPage[resultPage.URL] = resultPage
+		}
+	}
+
+	page := searchResultsPage
+
+	pageText, err := b.displayPage(page, cursor, 0, -1)
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to display page: %w", err)
+	}
+
+	return b.state.Data, pageText, nil
+}
+
+func (b *Browser) buildSearchResultsPageCollection(query string, results *WebSearchResponse) *responses.Page {
+	page := &responses.Page{
+		URL:       "search_results_" + query,
+		Title:     query,
+		Links:     make(map[int]string),
+		FetchedAt: time.Now(),
+	}
+
+	var textBuilder strings.Builder
+	linkIdx := 0
+
+	// Add the header lines to match format
+	textBuilder.WriteString("\n")                 // L0: empty
+	textBuilder.WriteString("URL: \n")            // L1: URL: (empty for search)
+	textBuilder.WriteString("# Search Results\n") // L2: # Search Results
+	textBuilder.WriteString("\n")                 // L3: empty
+
+	for _, queryResults := range results.Results {
+		for _, result := range queryResults {
+			domain := result.URL
+			if u, err := url.Parse(result.URL); err == nil && u.Host != "" {
+				domain = u.Host
+				domain = strings.TrimPrefix(domain, "www.")
+			}
+
+			linkFormat := fmt.Sprintf("* 【%d†%s†%s】", linkIdx, result.Title, domain)
+			textBuilder.WriteString(linkFormat)
+
+			numChars := min(len(result.Content.FullText), 400)
+			snippet := strings.TrimSpace(result.Content.FullText[:numChars])
+			textBuilder.WriteString(snippet)
+			textBuilder.WriteString("\n")
+
+			page.Links[linkIdx] = result.URL
+			linkIdx++
+		}
+	}
+
+	page.Text = textBuilder.String()
+	page.Lines = wrapLines(page.Text, 80)
+
+	return page
+}
+
+func (b *Browser) buildSearchResultsPage(result *WebSearchResult, linkIdx int) *responses.Page {
+	page := &responses.Page{
+		URL:       result.URL,
+		Title:     result.Title,
+		Links:     make(map[int]string),
+		FetchedAt: time.Now(),
+	}
+
+	var textBuilder strings.Builder
+
+	// Format the individual result page (only used when no full text is available)
+	linkFormat := fmt.Sprintf("【%d†%s】", linkIdx, result.Title)
+	textBuilder.WriteString(linkFormat)
+	textBuilder.WriteString("\n")
+	textBuilder.WriteString(fmt.Sprintf("URL: %s\n", result.URL))
+	numChars := min(len(result.Content.FullText), 300)
+	textBuilder.WriteString(result.Content.FullText[:numChars])
+	textBuilder.WriteString("\n\n")
+
+	// Only store link and snippet if we won't be processing full text later
+	// (full text processing will handle all links consistently)
+	if result.Content.FullText == "" {
+		page.Links[linkIdx] = result.URL
+	}
+
+	// Use full text if available, otherwise use snippet
+	if result.Content.FullText != "" {
+		// Prepend the URL line to the full text
+		page.Text = fmt.Sprintf("URL: %s\n%s", result.URL, result.Content.FullText)
+		// Process markdown links in the full text
+		processedText, processedLinks := processMarkdownLinks(page.Text)
+		page.Text = processedText
+		page.Links = processedLinks
+	} else {
+		page.Text = textBuilder.String()
+	}
+
+	page.Lines = wrapLines(page.Text, 80)
+
+	return page
+}
+
+// getEndLoc calculates the end location for viewport based on token limits
+func (b *Browser) getEndLoc(loc, numLines, totalLines int, lines []string) int {
+	if numLines <= 0 {
+		// Auto-calculate based on viewTokens
+		txt := b.joinLinesWithNumbers(lines[loc:])
+
+		// If text is very short, no need to truncate (at least 1 char per token)
+		if len(txt) > b.state.Data.ViewTokens {
+			// Simple heuristic: approximate token counting
+			// Typical token is ~4 characters, but can be up to 128 chars
+			maxCharsPerToken := 128
+
+			// upper bound for text to analyze
+			upperBound := min((b.state.Data.ViewTokens+1)*maxCharsPerToken, len(txt))
+			textToAnalyze := txt[:upperBound]
+
+			// Simple approximation: count tokens as ~4 chars each
+			// This is less accurate than tiktoken but more performant
+			approxTokens := len(textToAnalyze) / 4
+
+			if approxTokens > b.state.Data.ViewTokens {
+				// Find the character position at viewTokens
+				endIdx := min(b.state.Data.ViewTokens*4, len(txt))
+
+				// Count newlines up to that position to get line count
+				numLines = strings.Count(txt[:endIdx], "\n") + 1
+			} else {
+				numLines = totalLines
+			}
+		} else {
+			numLines = totalLines
+		}
+	}
+
+	return min(loc+numLines, totalLines)
+}
+
+// joinLinesWithNumbers creates a string with line numbers, matching Python's join_lines
+func (b *Browser) joinLinesWithNumbers(lines []string) string {
+	var builder strings.Builder
+	var hadZeroLine bool
+	for i, line := range lines {
+		if i == 0 {
+			builder.WriteString("L0:\n")
+			hadZeroLine = true
+		}
+		if hadZeroLine {
+			builder.WriteString(fmt.Sprintf("L%d: %s\n", i+1, line))
+		} else {
+			builder.WriteString(fmt.Sprintf("L%d: %s\n", i, line))
+		}
+	}
+	return builder.String()
+}
+
+// processMarkdownLinks finds all markdown links in the text and replaces them with the special format
+// Returns the processed text and a map of link IDs to URLs
+func processMarkdownLinks(text string) (string, map[int]string) {
+	links := make(map[int]string)
+
+	// Always start from 0 for consistent numbering across all pages
+	linkID := 0
+
+	// First, handle multi-line markdown links by joining them
+	// This regex finds markdown links that might be split across lines
+	multiLinePattern := regexp.MustCompile(`\[([^\]]+)\]\s*\n\s*\(([^)]+)\)`)
+	text = multiLinePattern.ReplaceAllStringFunc(text, func(match string) string {
+		// Replace newlines with spaces in the match
+		cleaned := strings.ReplaceAll(match, "\n", " ")
+		// Remove extra spaces
+		cleaned = regexp.MustCompile(`\s+`).ReplaceAllString(cleaned, " ")
+		return cleaned
+	})
+
+	// Now process all markdown links (including the cleaned multi-line ones)
+	linkPattern := regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`)
+
+	processedText := linkPattern.ReplaceAllStringFunc(text, func(match string) string {
+		matches := linkPattern.FindStringSubmatch(match)
+		if len(matches) != 3 {
+			return match
+		}
+
+		linkText := strings.TrimSpace(matches[1])
+		linkURL := strings.TrimSpace(matches[2])
+
+		// Extract domain from URL
+		domain := linkURL
+		if u, err := url.Parse(linkURL); err == nil && u.Host != "" {
+			domain = u.Host
+			// Remove www. prefix if present
+			domain = strings.TrimPrefix(domain, "www.")
+		}
+
+		// Create the formatted link
+		formatted := fmt.Sprintf("【%d†%s†%s】", linkID, linkText, domain)
+
+		// Store the link
+		links[linkID] = linkURL
+		linkID++
+
+		return formatted
+	})
+
+	return processedText, links
+}
+
+func wrapLines(text string, width int) []string {
+	if width <= 0 {
+		width = 80
+	}
+
+	lines := strings.Split(text, "\n")
+	var wrapped []string
+
+	for _, line := range lines {
+		if line == "" {
+			// Preserve empty lines
+			wrapped = append(wrapped, "")
+		} else if len(line) <= width {
+			wrapped = append(wrapped, line)
+		} else {
+			// Word wrapping while preserving whitespace structure
+			words := strings.Fields(line)
+			if len(words) == 0 {
+				// Line with only whitespace
+				wrapped = append(wrapped, line)
+				continue
+			}
+
+			currentLine := ""
+			for _, word := range words {
+				// Check if adding this word would exceed width
+				testLine := currentLine
+				if testLine != "" {
+					testLine += " "
+				}
+				testLine += word
+
+				if len(testLine) > width && currentLine != "" {
+					// Current line would be too long, wrap it
+					wrapped = append(wrapped, currentLine)
+					currentLine = word
+				} else {
+					// Add word to current line
+					if currentLine != "" {
+						currentLine += " "
+					}
+					currentLine += word
+				}
+			}
+
+			// Add any remaining content
+			if currentLine != "" {
+				wrapped = append(wrapped, currentLine)
+			}
+		}
+	}
+
+	return wrapped
+}
+
+// displayPage formats and returns the page display for the model
+func (b *Browser) displayPage(page *responses.Page, cursor, loc, numLines int) (string, error) {
+	totalLines := len(page.Lines)
+
+	if loc >= totalLines {
+		return "", fmt.Errorf("invalid location: %d (max: %d)", loc, totalLines-1)
+	}
+
+	// get viewport end location
+	endLoc := b.getEndLoc(loc, numLines, totalLines, page.Lines)
+
+	var displayBuilder strings.Builder
+	displayBuilder.WriteString(fmt.Sprintf("[%d] %s", cursor, page.Title))
+	if page.URL != "" {
+		displayBuilder.WriteString(fmt.Sprintf("(%s)\n", page.URL))
+	} else {
+		displayBuilder.WriteString("\n")
+	}
+	displayBuilder.WriteString(fmt.Sprintf("**viewing lines [%d - %d] of %d**\n\n", loc, endLoc-1, totalLines-1))
+
+	// Content with line numbers
+	var hadZeroLine bool
+	for i := loc; i < endLoc; i++ {
+		if i == 0 {
+			displayBuilder.WriteString("L0:\n")
+			hadZeroLine = true
+		}
+		if hadZeroLine {
+			displayBuilder.WriteString(fmt.Sprintf("L%d: %s\n", i+1, page.Lines[i]))
+		} else {
+			displayBuilder.WriteString(fmt.Sprintf("L%d: %s\n", i, page.Lines[i]))
+		}
+	}
+
+	return displayBuilder.String(), nil
+}
+
+type BrowserOpen struct {
+	Browser
+	crawlPage *BrowserCrawler
+}
+
+func NewBrowserOpen(bb *Browser) *BrowserOpen {
+	if bb == nil {
+		bb = &Browser{
+			state: &BrowserState{
+				Data: &responses.BrowserStateData{
+					PageStack:  []string{},
+					ViewTokens: DefaultViewTokens,
+					URLToPage:  make(map[string]*responses.Page),
+				},
+			},
+		}
+	}
+	return &BrowserOpen{
+		Browser:   *bb,
+		crawlPage: &BrowserCrawler{},
+	}
+}
+
+func (b *BrowserOpen) Name() string {
+	return "browser.open"
+}
+
+func (b *BrowserOpen) Description() string {
+	return "Open a link in the browser"
+}
+
+func (b *BrowserOpen) Prompt() string {
+	return ""
+}
+
+func (b *BrowserOpen) Schema() map[string]any {
+	return map[string]any{}
+}
+
+func (b *BrowserOpen) Execute(ctx context.Context, args map[string]any) (any, string, error) {
+	// Get cursor parameter first
+	cursor := -1
+	if c, ok := args["cursor"].(float64); ok {
+		cursor = int(c)
+	} else if c, ok := args["cursor"].(int); ok {
+		cursor = c
+	}
+
+	// Get loc parameter
+	loc := 0
+	if l, ok := args["loc"].(float64); ok {
+		loc = int(l)
+	} else if l, ok := args["loc"].(int); ok {
+		loc = l
+	}
+
+	// Get num_lines parameter
+	numLines := -1
+	if n, ok := args["num_lines"].(float64); ok {
+		numLines = int(n)
+	} else if n, ok := args["num_lines"].(int); ok {
+		numLines = n
+	}
+
+	// get page from cursor
+	var page *responses.Page
+	if cursor >= 0 {
+		if cursor >= len(b.state.Data.PageStack) {
+			return nil, "", fmt.Errorf("cursor %d is out of range (pageStack length: %d)", cursor, len(b.state.Data.PageStack))
+		}
+		var err error
+		page, err = b.getPageFromStack(b.state.Data.PageStack[cursor])
+		if err != nil {
+			return nil, "", fmt.Errorf("page not found for cursor %d: %w", cursor, err)
+		}
+	} else {
+		// get last page
+		if len(b.state.Data.PageStack) != 0 {
+			pageURL := b.state.Data.PageStack[len(b.state.Data.PageStack)-1]
+			var err error
+			page, err = b.getPageFromStack(pageURL)
+			if err != nil {
+				return nil, "", fmt.Errorf("page not found for cursor %d: %w", cursor, err)
+			}
+		}
+	}
+
+	// Try to get id as string (URL) first
+	if url, ok := args["id"].(string); ok {
+		// Check if we already have this page cached
+		if existingPage, ok := b.state.Data.URLToPage[url]; ok {
+			// Use cached page
+			b.savePage(existingPage)
+			// Always update cursor to point to the newly added page
+			cursor = len(b.state.Data.PageStack) - 1
+			pageText, err := b.displayPage(existingPage, cursor, loc, numLines)
+			if err != nil {
+				return nil, "", fmt.Errorf("failed to display page: %w", err)
+			}
+			return b.state.Data, pageText, nil
+		}
+
+		// Page not in cache, need to crawl it
+		if b.crawlPage == nil {
+			b.crawlPage = &BrowserCrawler{}
+		}
+		crawlResponse, err := b.crawlPage.Execute(ctx, map[string]any{
+			"urls":   []any{url},
+			"latest": false,
+		})
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to crawl URL %s: %w", url, err)
+		}
+
+		newPage, err := b.buildPageFromCrawlResult(url, crawlResponse)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to build page from crawl result: %w", err)
+		}
+
+		// Need to fall through if first search is directly an open command - no existing page
+		b.savePage(newPage)
+		// Always update cursor to point to the newly added page
+		cursor = len(b.state.Data.PageStack) - 1
+		pageText, err := b.displayPage(newPage, cursor, loc, numLines)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to display page: %w", err)
+		}
+		return b.state.Data, pageText, nil
+	}
+
+	// Try to get id as integer (link ID from current page)
+	if id, ok := args["id"].(float64); ok {
+		if page == nil {
+			return nil, "", fmt.Errorf("no current page to resolve link from")
+		}
+		idInt := int(id)
+		pageURL, ok := page.Links[idInt]
+		if !ok {
+			return nil, "", fmt.Errorf("invalid link id %d", idInt)
+		}
+
+		// Check if we have the linked page cached
+		newPage, ok := b.state.Data.URLToPage[pageURL]
+		if !ok {
+			if b.crawlPage == nil {
+				b.crawlPage = &BrowserCrawler{}
+			}
+			crawlResponse, err := b.crawlPage.Execute(ctx, map[string]any{
+				"urls":   []any{pageURL},
+				"latest": false,
+			})
+			if err != nil {
+				return nil, "", fmt.Errorf("failed to crawl URL %s: %w", pageURL, err)
+			}
+
+			// Create new page from crawl result
+			newPage, err = b.buildPageFromCrawlResult(pageURL, crawlResponse)
+			if err != nil {
+				return nil, "", fmt.Errorf("failed to build page from crawl result: %w", err)
+			}
+		}
+
+		// Add to history stack regardless of cache status
+		b.savePage(newPage)
+
+		// Always update cursor to point to the newly added page
+		cursor = len(b.state.Data.PageStack) - 1
+		pageText, err := b.displayPage(newPage, cursor, loc, numLines)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to display page: %w", err)
+		}
+		return b.state.Data, pageText, nil
+	}
+
+	// If no id provided, just display current page
+	if page == nil {
+		return nil, "", fmt.Errorf("no current page to display")
+	}
+	// Only add to PageStack without updating URLToPage
+	b.state.Data.PageStack = append(b.state.Data.PageStack, page.URL)
+	cursor = len(b.state.Data.PageStack) - 1
+
+	pageText, err := b.displayPage(page, cursor, loc, numLines)
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to display page: %w", err)
+	}
+	return b.state.Data, pageText, nil
+}
+
+// buildPageFromCrawlResult creates a Page from crawl API results
+func (b *Browser) buildPageFromCrawlResult(requestedURL string, crawlResponse *CrawlResponse) (*responses.Page, error) {
+	// Initialize page with defaults
+	page := &responses.Page{
+		URL:       requestedURL,
+		Title:     requestedURL,
+		Text:      "",
+		Links:     make(map[int]string),
+		FetchedAt: time.Now(),
+	}
+
+	// Process crawl results - the API returns results grouped by URL
+	for url, urlResults := range crawlResponse.Results {
+		if len(urlResults) > 0 {
+			// Get the first result for this URL
+			result := urlResults[0]
+
+			// Extract content
+			if result.Content.FullText != "" {
+				page.Text = result.Content.FullText
+			}
+
+			// Extract title if available
+			if result.Title != "" {
+				page.Title = result.Title
+			}
+
+			// Update URL to the actual URL from results
+			page.URL = url
+
+			// Extract links if available from extras
+			for i, link := range result.Extras.Links {
+				if link.Href != "" {
+					page.Links[i] = link.Href
+				} else if link.URL != "" {
+					page.Links[i] = link.URL
+				}
+			}
+
+			// Only process the first URL's results
+			break
+		}
+	}
+
+	// If no text was extracted, set a default message
+	if page.Text == "" {
+		page.Text = "No content could be extracted from this page."
+	} else {
+		// Prepend the URL line to match Python implementation
+		page.Text = fmt.Sprintf("URL: %s\n%s", page.URL, page.Text)
+	}
+
+	// Process markdown links in the text
+	processedText, processedLinks := processMarkdownLinks(page.Text)
+	page.Text = processedText
+	page.Links = processedLinks
+
+	// Wrap lines for display
+	page.Lines = wrapLines(page.Text, 80)
+
+	return page, nil
+}
+
+type BrowserFind struct {
+	Browser
+}
+
+func NewBrowserFind(bb *Browser) *BrowserFind {
+	return &BrowserFind{
+		Browser: *bb,
+	}
+}
+
+func (b *BrowserFind) Name() string {
+	return "browser.find"
+}
+
+func (b *BrowserFind) Description() string {
+	return "Find a term in the browser"
+}
+
+func (b *BrowserFind) Prompt() string {
+	return ""
+}
+
+func (b *BrowserFind) Schema() map[string]any {
+	return map[string]any{}
+}
+
+func (b *BrowserFind) Execute(ctx context.Context, args map[string]any) (any, string, error) {
+	pattern, ok := args["pattern"].(string)
+	if !ok {
+		return nil, "", fmt.Errorf("pattern parameter is required")
+	}
+
+	// Get cursor parameter if provided, default to current page
+	cursor := -1
+	if c, ok := args["cursor"].(float64); ok {
+		cursor = int(c)
+	}
+
+	// Get the page to search in
+	var page *responses.Page
+	if cursor == -1 {
+		// Use current page
+		if len(b.state.Data.PageStack) == 0 {
+			return nil, "", fmt.Errorf("no pages to search in")
+		}
+		var err error
+		page, err = b.getPageFromStack(b.state.Data.PageStack[len(b.state.Data.PageStack)-1])
+		if err != nil {
+			return nil, "", fmt.Errorf("page not found for cursor %d: %w", cursor, err)
+		}
+	} else {
+		// Use specific cursor
+		if cursor < 0 || cursor >= len(b.state.Data.PageStack) {
+			return nil, "", fmt.Errorf("cursor %d is out of range [0-%d]", cursor, len(b.state.Data.PageStack)-1)
+		}
+		var err error
+		page, err = b.getPageFromStack(b.state.Data.PageStack[cursor])
+		if err != nil {
+			return nil, "", fmt.Errorf("page not found for cursor %d: %w", cursor, err)
+		}
+	}
+
+	if page == nil {
+		return nil, "", fmt.Errorf("page not found")
+	}
+
+	// Create find results page
+	findPage := b.buildFindResultsPage(pattern, page)
+
+	// Add the find results page to state
+	b.savePage(findPage)
+	newCursor := len(b.state.Data.PageStack) - 1
+
+	pageText, err := b.displayPage(findPage, newCursor, 0, -1)
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to display page: %w", err)
+	}
+
+	return b.state.Data, pageText, nil
+}
+
+func (b *Browser) buildFindResultsPage(pattern string, page *responses.Page) *responses.Page {
+	findPage := &responses.Page{
+		Title:     fmt.Sprintf("Find results for text: `%s` in `%s`", pattern, page.Title),
+		Links:     make(map[int]string),
+		FetchedAt: time.Now(),
+	}
+
+	findPage.URL = fmt.Sprintf("find_results_%s", pattern)
+
+	var textBuilder strings.Builder
+	matchIdx := 0
+	maxResults := 50
+	numShowLines := 4
+	patternLower := strings.ToLower(pattern)
+
+	// Search through the page lines following the reference algorithm
+	var resultChunks []string
+	lineIdx := 0
+
+	for lineIdx < len(page.Lines) {
+		line := page.Lines[lineIdx]
+		lineLower := strings.ToLower(line)
+
+		if !strings.Contains(lineLower, patternLower) {
+			lineIdx++
+			continue
+		}
+
+		// Build snippet context
+		endLine := min(lineIdx+numShowLines, len(page.Lines))
+
+		var snippetBuilder strings.Builder
+		for j := lineIdx; j < endLine; j++ {
+			snippetBuilder.WriteString(page.Lines[j])
+			if j < endLine-1 {
+				snippetBuilder.WriteString("\n")
+			}
+		}
+		snippet := snippetBuilder.String()
+
+		// Format the match
+		linkFormat := fmt.Sprintf("【%d†match at L%d】", matchIdx, lineIdx)
+		resultChunk := fmt.Sprintf("%s\n%s", linkFormat, snippet)
+		resultChunks = append(resultChunks, resultChunk)
+
+		if len(resultChunks) >= maxResults {
+			break
+		}
+
+		matchIdx++
+		lineIdx += numShowLines
+	}
+
+	// Build final display text
+	if len(resultChunks) > 0 {
+		textBuilder.WriteString(strings.Join(resultChunks, "\n\n"))
+	}
+
+	if matchIdx == 0 {
+		findPage.Text = fmt.Sprintf("No `find` results for pattern: `%s`", pattern)
+	} else {
+		findPage.Text = textBuilder.String()
+	}
+
+	findPage.Lines = wrapLines(findPage.Text, 80)
+	return findPage
+}

app/tools/browser_crawl.go

@@ -0,0 +1,136 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// CrawlContent represents the content of a crawled page
+type CrawlContent struct {
+	Snippet  string `json:"snippet"`
+	FullText string `json:"full_text"`
+}
+
+// CrawlExtras represents additional data from the crawl API
+type CrawlExtras struct {
+	Links []CrawlLink `json:"links"`
+}
+
+// CrawlLink represents a link found on a crawled page
+type CrawlLink struct {
+	URL  string `json:"url"`
+	Href string `json:"href"`
+	Text string `json:"text"`
+}
+
+// CrawlResult represents a single crawl result
+type CrawlResult struct {
+	Title   string       `json:"title"`
+	URL     string       `json:"url"`
+	Content CrawlContent `json:"content"`
+	Extras  CrawlExtras  `json:"extras"`
+}
+
+// CrawlResponse represents the complete response from the crawl API
+type CrawlResponse struct {
+	Results map[string][]CrawlResult `json:"results"`
+}
+
+// BrowserCrawler tool for crawling web pages using ollama.com crawl API
+type BrowserCrawler struct{}
+
+func (g *BrowserCrawler) Name() string {
+	return "get_webpage"
+}
+
+func (g *BrowserCrawler) Description() string {
+	return "Crawl and extract text content from web pages"
+}
+
+func (g *BrowserCrawler) Prompt() string {
+	return `When you need to read content from web pages, use the get_webpage tool. Simply provide the URLs you want to read and I'll fetch their content for you.
+
+For each URL, I'll extract the main text content in a readable format. If you need to discover links within those pages, set extract_links to true. If the user requires the latest information, set livecrawl to true.
+
+Only use this tool when you need to access current web content. Make sure the URLs are valid and accessible. Do not use this tool for:
+- Downloading files or media
+- Accessing private/authenticated pages
+- Scraping data at high volumes
+
+Always check the returned content to ensure it's relevant before using it in your response.`
+}
+
+func (g *BrowserCrawler) Schema() map[string]any {
+	schemaBytes := []byte(`{
+		"type": "object",
+		"properties": {
+			"urls": {
+				"type": "array",
+				"items": {
+					"type": "string"
+				},
+				"description": "List of URLs to crawl and extract content from"
+			}
+		},
+		"required": ["urls"]
+	}`)
+	var schema map[string]any
+	if err := json.Unmarshal(schemaBytes, &schema); err != nil {
+		return nil
+	}
+	return schema
+}
+
+func (g *BrowserCrawler) Execute(ctx context.Context, args map[string]any) (*CrawlResponse, error) {
+	urlsRaw, ok := args["urls"].([]any)
+	if !ok {
+		return nil, fmt.Errorf("urls parameter is required and must be an array of strings")
+	}
+
+	urls := make([]string, 0, len(urlsRaw))
+	for _, u := range urlsRaw {
+		if urlStr, ok := u.(string); ok {
+			urls = append(urls, urlStr)
+		}
+	}
+
+	if len(urls) == 0 {
+		return nil, fmt.Errorf("at least one URL is required")
+	}
+
+	return g.performWebCrawl(ctx, urls)
+}
+
+// performWebCrawl handles the actual HTTP request to ollama.com crawl API
+func (g *BrowserCrawler) performWebCrawl(ctx context.Context, urls []string) (*CrawlResponse, error) {
+	result := &CrawlResponse{Results: make(map[string][]CrawlResult, len(urls))}
+
+	for _, targetURL := range urls {
+		fetchResp, err := performWebFetch(ctx, targetURL)
+		if err != nil {
+			return nil, fmt.Errorf("web_fetch failed for %q: %w", targetURL, err)
+		}
+
+		links := make([]CrawlLink, 0, len(fetchResp.Links))
+		for _, link := range fetchResp.Links {
+			links = append(links, CrawlLink{URL: link, Href: link})
+		}
+
+		snippet := truncateString(fetchResp.Content, 400)
+
+		result.Results[targetURL] = []CrawlResult{{
+			Title: fetchResp.Title,
+			URL:   targetURL,
+			Content: CrawlContent{
+				Snippet:  snippet,
+				FullText: fetchResp.Content,
+			},
+			Extras: CrawlExtras{Links: links},
+		}}
+	}
+
+	return result, nil
+}

app/tools/browser_test.go

@@ -0,0 +1,147 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ollama/ollama/app/ui/responses"
+)
+
+func makeTestPage(url string) *responses.Page {
+	return &responses.Page{
+		URL:       url,
+		Title:     "Title " + url,
+		Text:      "Body for " + url,
+		Lines:     []string{"line1", "line2", "line3"},
+		Links:     map[int]string{0: url},
+		FetchedAt: time.Now(),
+	}
+}
+
+func TestBrowser_Scroll_AppendsOnlyPageStack(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	p1 := makeTestPage("https://example.com/1")
+	b.savePage(p1)
+	initialStackLen := len(b.state.Data.PageStack)
+	initialMapLen := len(b.state.Data.URLToPage)
+
+	bo := NewBrowserOpen(b)
+	// Scroll without id — should push only to PageStack
+	_, _, err := bo.Execute(t.Context(), map[string]any{"loc": float64(1), "num_lines": float64(1)})
+	if err != nil {
+		t.Fatalf("scroll execute failed: %v", err)
+	}
+
+	if got, want := len(b.state.Data.PageStack), initialStackLen+1; got != want {
+		t.Fatalf("page stack length = %d, want %d", got, want)
+	}
+	if got, want := len(b.state.Data.URLToPage), initialMapLen; got != want {
+		t.Fatalf("url_to_page length changed = %d, want %d", got, want)
+	}
+}
+
+func TestBrowserOpen_UseCacheByURL(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	bo := NewBrowserOpen(b)
+
+	p := makeTestPage("https://example.com/cached")
+	b.state.Data.URLToPage[p.URL] = p
+	initialStackLen := len(b.state.Data.PageStack)
+	initialMapLen := len(b.state.Data.URLToPage)
+
+	_, _, err := bo.Execute(t.Context(), map[string]any{"id": p.URL})
+	if err != nil {
+		t.Fatalf("open cached execute failed: %v", err)
+	}
+
+	if got, want := len(b.state.Data.PageStack), initialStackLen+1; got != want {
+		t.Fatalf("page stack length = %d, want %d", got, want)
+	}
+	if got, want := len(b.state.Data.URLToPage), initialMapLen; got != want {
+		t.Fatalf("url_to_page length changed = %d, want %d", got, want)
+	}
+}
+
+func TestDisplayPage_InvalidLoc(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	p := makeTestPage("https://example.com/x")
+	// ensure lines are set
+	p.Lines = []string{"a", "b"}
+	_, err := b.displayPage(p, 0, 10, -1)
+	if err == nil || !strings.Contains(err.Error(), "invalid location") {
+		t.Fatalf("expected invalid location error, got %v", err)
+	}
+}
+
+func TestBrowserOpen_LinkId_UsesCacheAndAppends(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	// Seed a main page with a link id 0 to a linked URL
+	main := makeTestPage("https://example.com/main")
+	linked := makeTestPage("https://example.com/linked")
+	main.Links = map[int]string{0: linked.URL}
+	// Save the main page (adds to PageStack and URLToPage)
+	b.savePage(main)
+	// Pre-cache the linked page so open by id avoids network
+	b.state.Data.URLToPage[linked.URL] = linked
+
+	initialStackLen := len(b.state.Data.PageStack)
+	initialMapLen := len(b.state.Data.URLToPage)
+
+	bo := NewBrowserOpen(b)
+	_, _, err := bo.Execute(t.Context(), map[string]any{"id": float64(0)})
+	if err != nil {
+		t.Fatalf("open by link id failed: %v", err)
+	}
+
+	if got, want := len(b.state.Data.PageStack), initialStackLen+1; got != want {
+		t.Fatalf("page stack length = %d, want %d", got, want)
+	}
+	if got, want := len(b.state.Data.URLToPage), initialMapLen; got != want {
+		t.Fatalf("url_to_page length changed = %d, want %d", got, want)
+	}
+	if last := b.state.Data.PageStack[len(b.state.Data.PageStack)-1]; last != linked.URL {
+		t.Fatalf("last page in stack = %s, want %s", last, linked.URL)
+	}
+}
+
+func TestWrapLines_PreserveAndWidth(t *testing.T) {
+	long := strings.Repeat("word ", 50)
+	text := "Line1\n\n" + long + "\nLine3"
+	lines := wrapLines(text, 40)
+
+	// Ensure empty line preserved at index 1
+	if lines[1] != "" {
+		t.Fatalf("expected preserved empty line at index 1, got %q", lines[1])
+	}
+	// All lines should be <= 40 chars
+	for i, l := range lines {
+		if len(l) > 40 {
+			t.Fatalf("line %d exceeds width: %d > 40", i, len(l))
+		}
+	}
+}
+
+func TestDisplayPage_FormatHeaderAndLines(t *testing.T) {
+	b := NewBrowser(&responses.BrowserStateData{PageStack: []string{}, ViewTokens: 1024, URLToPage: map[string]*responses.Page{}})
+	p := &responses.Page{
+		URL:   "https://example.com/x",
+		Title: "Example",
+		Lines: []string{"URL: https://example.com/x", "A", "B", "C"},
+	}
+	out, err := b.displayPage(p, 3, 0, 2)
+	if err != nil {
+		t.Fatalf("displayPage failed: %v", err)
+	}
+	if !strings.HasPrefix(out, "[3] Example(") {
+		t.Fatalf("header not formatted as expected: %q", out)
+	}
+	if !strings.Contains(out, "L0:\n") {
+		t.Fatalf("missing L0 label: %q", out)
+	}
+	if !strings.Contains(out, "L1: URL: https://example.com/x\n") || !strings.Contains(out, "L2: A\n") {
+		t.Fatalf("missing expected line numbers/content: %q", out)
+	}
+}

app/tools/browser_websearch.go

@@ -0,0 +1,143 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// WebSearchContent represents the content of a search result
+type WebSearchContent struct {
+	Snippet  string `json:"snippet"`
+	FullText string `json:"full_text"`
+}
+
+// WebSearchMetadata represents metadata for a search result
+type WebSearchMetadata struct {
+	PublishedDate *time.Time `json:"published_date,omitempty"`
+}
+
+// WebSearchResult represents a single search result
+type WebSearchResult struct {
+	Title    string            `json:"title"`
+	URL      string            `json:"url"`
+	Content  WebSearchContent  `json:"content"`
+	Metadata WebSearchMetadata `json:"metadata"`
+}
+
+// WebSearchResponse represents the complete response from the websearch API
+type WebSearchResponse struct {
+	Results map[string][]WebSearchResult `json:"results"`
+}
+
+// BrowserWebSearch tool for searching the web using ollama.com search API
+type BrowserWebSearch struct{}
+
+func (w *BrowserWebSearch) Name() string {
+	return "gpt_oss_web_search"
+}
+
+func (w *BrowserWebSearch) Description() string {
+	return "Search the web for real-time information using ollama.com search API."
+}
+
+func (w *BrowserWebSearch) Prompt() string {
+	return `Use the gpt_oss_web_search tool to search the web.
+1. Come up with a list of search queries to get comprehensive information (typically 2-3 related queries work well)
+2. Use the gpt_oss_web_search tool with multiple queries to get results organized by query
+3. Use the search results to provide current up to date, accurate information
+
+Today's date is ` + time.Now().Format("January 2, 2006") + `
+Add "` + time.Now().Format("January 2, 2006") + `" for news queries and ` + strconv.Itoa(time.Now().Year()+1) + ` for other queries that need current information.`
+}
+
+func (w *BrowserWebSearch) Schema() map[string]any {
+	schemaBytes := []byte(`{
+		"type": "object",
+		"properties": {
+			"queries": {
+				"type": "array",
+				"items": {
+					"type": "string"
+				},
+				"description": "List of search queries to look up"
+			},
+			"max_results": {
+				"type": "integer",
+				"description": "Maximum number of results to return per query (default: 2) up to 5",
+				"default": 2
+			}
+		},
+		"required": ["queries"]
+	}`)
+	var schema map[string]any
+	if err := json.Unmarshal(schemaBytes, &schema); err != nil {
+		return nil
+	}
+	return schema
+}
+
+func (w *BrowserWebSearch) Execute(ctx context.Context, args map[string]any) (any, error) {
+	queriesRaw, ok := args["queries"].([]any)
+	if !ok {
+		return nil, fmt.Errorf("queries parameter is required and must be an array of strings")
+	}
+
+	queries := make([]string, 0, len(queriesRaw))
+	for _, q := range queriesRaw {
+		if query, ok := q.(string); ok {
+			queries = append(queries, query)
+		}
+	}
+
+	if len(queries) == 0 {
+		return nil, fmt.Errorf("at least one query is required")
+	}
+
+	maxResults := 5
+	if mr, ok := args["max_results"].(int); ok {
+		maxResults = mr
+	}
+
+	return w.performWebSearch(ctx, queries, maxResults)
+}
+
+// performWebSearch handles the actual HTTP request to ollama.com search API
+func (w *BrowserWebSearch) performWebSearch(ctx context.Context, queries []string, maxResults int) (*WebSearchResponse, error) {
+	response := &WebSearchResponse{Results: make(map[string][]WebSearchResult, len(queries))}
+
+	for _, query := range queries {
+		searchResp, err := performWebSearch(ctx, query, maxResults)
+		if err != nil {
+			return nil, fmt.Errorf("web_search failed for %q: %w", query, err)
+		}
+
+		converted := make([]WebSearchResult, 0, len(searchResp.Results))
+		for _, item := range searchResp.Results {
+			converted = append(converted, WebSearchResult{
+				Title: item.Title,
+				URL:   item.URL,
+				Content: WebSearchContent{
+					Snippet:  truncateString(item.Content, 400),
+					FullText: item.Content,
+				},
+				Metadata: WebSearchMetadata{},
+			})
+		}
+
+		response.Results[query] = converted
+	}
+
+	return response, nil
+}
+
+func truncateString(input string, limit int) string {
+	if limit <= 0 || len(input) <= limit {
+		return input
+	}
+	return input[:limit]
+}

app/tools/cloud_policy.go

@@ -0,0 +1,35 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ollama/ollama/api"
+	internalcloud "github.com/ollama/ollama/internal/cloud"
+)
+
+// ensureCloudEnabledForTool checks cloud policy from the connected Ollama server.
+// If policy cannot be determined, this fails closed and blocks the operation.
+func ensureCloudEnabledForTool(ctx context.Context, operation string) error {
+	// Reuse shared message formatting; policy evaluation is still done via
+	// the connected server's /api/status endpoint below.
+	disabledMessage := internalcloud.DisabledError(operation)
+
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
+	}
+
+	status, err := client.CloudStatusExperimental(ctx)
+	if err != nil {
+		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
+	}
+
+	if status.Cloud.Disabled {
+		return errors.New(disabledMessage)
+	}
+
+	return nil
+}

app/tools/cloud_policy_test.go

@@ -0,0 +1,73 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestEnsureCloudEnabledForTool(t *testing.T) {
+	const op = "web search is unavailable"
+	const disabledPrefix = "ollama cloud is disabled: web search is unavailable"
+
+	t.Run("enabled allows tool execution", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path != "/api/status" {
+				http.NotFound(w, r)
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"cloud":{"disabled":false,"source":"none"}}`))
+		}))
+		t.Cleanup(ts.Close)
+		t.Setenv("OLLAMA_HOST", ts.URL)
+
+		if err := ensureCloudEnabledForTool(context.Background(), op); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+	})
+
+	t.Run("disabled blocks tool execution", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path != "/api/status" {
+				http.NotFound(w, r)
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"cloud":{"disabled":true,"source":"config"}}`))
+		}))
+		t.Cleanup(ts.Close)
+		t.Setenv("OLLAMA_HOST", ts.URL)
+
+		err := ensureCloudEnabledForTool(context.Background(), op)
+		if err == nil {
+			t.Fatal("expected error, got nil")
+		}
+		if got := err.Error(); got != disabledPrefix {
+			t.Fatalf("unexpected error: %q", got)
+		}
+	})
+
+	t.Run("status unavailable fails closed", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			http.NotFound(w, r)
+		}))
+		t.Cleanup(ts.Close)
+		t.Setenv("OLLAMA_HOST", ts.URL)
+
+		err := ensureCloudEnabledForTool(context.Background(), op)
+		if err == nil {
+			t.Fatal("expected error, got nil")
+		}
+		if got := err.Error(); !strings.Contains(got, disabledPrefix) {
+			t.Fatalf("expected disabled prefix, got %q", got)
+		}
+		if got := err.Error(); !strings.Contains(got, "unable to verify server cloud policy") {
+			t.Fatalf("expected verification failure detail, got %q", got)
+		}
+	})
+}

app/tools/tools.go

@@ -0,0 +1,122 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Tool defines the interface that all tools must implement
+type Tool interface {
+	// Name returns the unique identifier for the tool
+	Name() string
+
+	// Description returns a human-readable description of what the tool does
+	Description() string
+
+	// Schema returns the JSON schema for the tool's parameters
+	Schema() map[string]any
+
+	// Execute runs the tool with the given arguments and returns result to store in db, and a string result for the model
+	Execute(ctx context.Context, args map[string]any) (any, string, error)
+
+	// Prompt returns a prompt for the tool
+	Prompt() string
+}
+
+// Registry manages the available tools and their execution
+type Registry struct {
+	tools      map[string]Tool
+	workingDir string // Working directory for all tool operations
+}
+
+// NewRegistry creates a new tool registry with no tools
+func NewRegistry() *Registry {
+	return &Registry{
+		tools: make(map[string]Tool),
+	}
+}
+
+// Register adds a tool to the registry
+func (r *Registry) Register(tool Tool) {
+	r.tools[tool.Name()] = tool
+}
+
+// Get retrieves a tool by name
+func (r *Registry) Get(name string) (Tool, bool) {
+	tool, exists := r.tools[name]
+	return tool, exists
+}
+
+// List returns all available tools
+func (r *Registry) List() []Tool {
+	tools := make([]Tool, 0, len(r.tools))
+	for _, tool := range r.tools {
+		tools = append(tools, tool)
+	}
+	return tools
+}
+
+// SetWorkingDir sets the working directory for all tool operations
+func (r *Registry) SetWorkingDir(dir string) {
+	r.workingDir = dir
+}
+
+// Execute runs a tool with the given name and arguments
+func (r *Registry) Execute(ctx context.Context, name string, args map[string]any) (any, string, error) {
+	tool, ok := r.tools[name]
+	if !ok {
+		return nil, "", fmt.Errorf("unknown tool: %s", name)
+	}
+
+	result, text, err := tool.Execute(ctx, args)
+	if err != nil {
+		return nil, "", err
+	}
+	return result, text, nil
+}
+
+// ToolCall represents a request to execute a tool
+type ToolCall struct {
+	ID       string       `json:"id"`
+	Type     string       `json:"type"`
+	Function ToolFunction `json:"function"`
+}
+
+// ToolFunction represents the function call details
+type ToolFunction struct {
+	Name      string          `json:"name"`
+	Arguments json.RawMessage `json:"arguments"`
+}
+
+// ToolResult represents the result of a tool execution
+type ToolResult struct {
+	ToolCallID string `json:"tool_call_id"`
+	Content    any    `json:"content"`
+	Error      string `json:"error,omitempty"`
+}
+
+// ToolSchemas returns all tools as schema maps suitable for API calls
+func (r *Registry) AvailableTools() []map[string]any {
+	schemas := make([]map[string]any, 0, len(r.tools))
+	for _, tool := range r.tools {
+		schema := map[string]any{
+			"name":        tool.Name(),
+			"description": tool.Description(),
+			"schema":      tool.Schema(),
+		}
+		schemas = append(schemas, schema)
+	}
+	return schemas
+}
+
+// ToolNames returns a list of all tool names
+func (r *Registry) ToolNames() []string {
+	names := make([]string, 0, len(r.tools))
+	for name := range r.tools {
+		names = append(names, name)
+	}
+	return names
+}

app/tools/web_fetch.go

@@ -0,0 +1,132 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/auth"
+)
+
+type WebFetch struct{}
+
+type FetchRequest struct {
+	URL string `json:"url"`
+}
+
+type FetchResponse struct {
+	Title   string   `json:"title"`
+	Content string   `json:"content"`
+	Links   []string `json:"links"`
+}
+
+func (w *WebFetch) Name() string {
+	return "web_fetch"
+}
+
+func (w *WebFetch) Description() string {
+	return "Crawl and extract text content from web pages"
+}
+
+func (g *WebFetch) Schema() map[string]any {
+	schemaBytes := []byte(`{
+		"type": "object",
+		"properties": {
+			"url": {
+				"type": "string",
+				"description": "URL to crawl and extract content from"
+            }
+		},
+		"required": ["url"]
+	}`)
+	var schema map[string]any
+	if err := json.Unmarshal(schemaBytes, &schema); err != nil {
+		return nil
+	}
+	return schema
+}
+
+func (w *WebFetch) Prompt() string {
+	return ""
+}
+
+func (w *WebFetch) Execute(ctx context.Context, args map[string]any) (any, string, error) {
+	urlRaw, ok := args["url"]
+	if !ok {
+		return nil, "", fmt.Errorf("url parameter is required")
+	}
+	urlStr, ok := urlRaw.(string)
+	if !ok || strings.TrimSpace(urlStr) == "" {
+		return nil, "", fmt.Errorf("url must be a non-empty string")
+	}
+
+	result, err := performWebFetch(ctx, urlStr)
+	if err != nil {
+		return nil, "", err
+	}
+
+	return result, "", nil
+}
+
+func performWebFetch(ctx context.Context, targetURL string) (*FetchResponse, error) {
+	if err := ensureCloudEnabledForTool(ctx, "web fetch is unavailable"); err != nil {
+		return nil, err
+	}
+
+	reqBody := FetchRequest{URL: targetURL}
+	jsonBody, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request body: %w", err)
+	}
+
+	crawlURL, err := url.Parse("https://ollama.com/api/web_fetch")
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse fetch URL: %w", err)
+	}
+
+	query := crawlURL.Query()
+	query.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	crawlURL.RawQuery = query.Encode()
+
+	data := fmt.Appendf(nil, "%s,%s", http.MethodPost, crawlURL.RequestURI())
+	signature, err := auth.Sign(ctx, data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, crawlURL.String(), bytes.NewBuffer(jsonBody))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if signature != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
+	}
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute fetch request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("fetch API error (status %d)", resp.StatusCode)
+	}
+
+	var result FetchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}

app/tools/web_search.go

@@ -0,0 +1,149 @@
+//go:build windows || darwin
+
+package tools
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ollama/ollama/auth"
+)
+
+type WebSearch struct{}
+
+type SearchRequest struct {
+	Query      string `json:"query"`
+	MaxResults int    `json:"max_results,omitempty"`
+}
+
+type SearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Content string `json:"content"`
+}
+
+type SearchResponse struct {
+	Results []SearchResult `json:"results"`
+}
+
+func (w *WebSearch) Name() string {
+	return "web_search"
+}
+
+func (w *WebSearch) Description() string {
+	return "Search the web for real-time information using ollama.com web search API."
+}
+
+func (w *WebSearch) Prompt() string {
+	return ""
+}
+
+func (g *WebSearch) Schema() map[string]any {
+	schemaBytes := []byte(`{
+		"type": "object",
+		"properties": {
+			"query": {
+				"type": "string",
+				"description": "The search query to execute"
+			},
+			"max_results": {
+				"type": "integer",
+				"description": "Maximum number of search results to return",
+				"default": 3
+			}
+		},
+		"required": ["query"]
+	}`)
+	var schema map[string]any
+	if err := json.Unmarshal(schemaBytes, &schema); err != nil {
+		return nil
+	}
+	return schema
+}
+
+func (w *WebSearch) Execute(ctx context.Context, args map[string]any) (any, string, error) {
+	rawQuery, ok := args["query"]
+	if !ok {
+		return nil, "", fmt.Errorf("query parameter is required")
+	}
+
+	queryStr, ok := rawQuery.(string)
+	if !ok || strings.TrimSpace(queryStr) == "" {
+		return nil, "", fmt.Errorf("query must be a non-empty string")
+	}
+
+	maxResults := 5
+	if v, ok := args["max_results"].(float64); ok && int(v) > 0 {
+		maxResults = int(v)
+	}
+
+	result, err := performWebSearch(ctx, queryStr, maxResults)
+	if err != nil {
+		return nil, "", err
+	}
+
+	return result, "", nil
+}
+
+func performWebSearch(ctx context.Context, query string, maxResults int) (*SearchResponse, error) {
+	if err := ensureCloudEnabledForTool(ctx, "web search is unavailable"); err != nil {
+		return nil, err
+	}
+
+	reqBody := SearchRequest{Query: query, MaxResults: maxResults}
+
+	jsonBody, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request body: %w", err)
+	}
+
+	searchURL, err := url.Parse("https://ollama.com/api/web_search")
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse search URL: %w", err)
+	}
+
+	q := searchURL.Query()
+	q.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	searchURL.RawQuery = q.Encode()
+
+	data := fmt.Appendf(nil, "%s,%s", http.MethodPost, searchURL.RequestURI())
+	signature, err := auth.Sign(ctx, data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, searchURL.String(), bytes.NewBuffer(jsonBody))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if signature != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute search request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("search API error (status %d)", resp.StatusCode)
+	}
+
+	var result SearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}

app/types/not/found.go

@@ -0,0 +1,28 @@
+//go:build windows || darwin
+
+package not
+
+import (
+	"errors"
+)
+
+// Found is an error that indicates that a value was not found. It
+// may be used by low-level packages to signal to higher-level
+// packages that a value was not found.
+//
+// It exists to avoid using errors.New("not found") in multiple
+// packages to mean the same thing.
+//
+// Found should not be used directly. Instead it should be wrapped
+// or joined using errors.Join or fmt.Errorf, etc.
+//
+// Errors wrapping Found should provide additional context, e.g.
+// fmt.Errorf("%w: %s", not.Found, key)
+//
+//lint:ignore ST1012 This is a sentinel error intended to be read like not.Found.
+var Found = errors.New("not found")
+
+// Available is an error that indicates that a value is not available.
+//
+//lint:ignore ST1012 This is a sentinel error intended to be read like not.Available.
+var Available = errors.New("not available")

app/types/not/valids.go

@@ -0,0 +1,55 @@
+//go:build windows || darwin
+
+package not
+
+import (
+	"fmt"
+)
+
+type ValidError struct {
+	name string
+	msg  string
+	args []any
+}
+
+// Valid returns a new validation error with the given name and message.
+func Valid(name, message string, args ...any) error {
+	return ValidError{name, message, args}
+}
+
+// Message returns the formatted message for the validation error.
+func (e *ValidError) Message() string {
+	return fmt.Sprintf(e.msg, e.args...)
+}
+
+// Error implements the error interface.
+func (e ValidError) Error() string {
+	return fmt.Sprintf("invalid %s: %s", e.name, e.Message())
+}
+
+func (e ValidError) Field() string {
+	return e.name
+}
+
+// Valids is for building a list of validation errors.
+type Valids []ValidError
+
+// Addf adds a validation error to the list with a formatted message using fmt.Sprintf.
+func (b *Valids) Add(name, message string, args ...any) {
+	*b = append(*b, ValidError{name, message, args})
+}
+
+func (b Valids) Error() string {
+	if len(b) == 0 {
+		return ""
+	}
+
+	var result string
+	for i, err := range b {
+		if i > 0 {
+			result += "; "
+		}
+		result += err.Error()
+	}
+	return result
+}

app/types/not/valids_test.go

@@ -0,0 +1,43 @@
+//go:build windows || darwin
+
+package not_test
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ollama/ollama/app/types/not"
+)
+
+func ExampleValids() {
+	// This example demonstrates how to use the Valids type to create
+	// a list of validation errors.
+	//
+	// The Valids type is a slice of ValidError values. Each ValidError
+	// value represents a validation error.
+	//
+	// The Valids type has an Error method that returns a single error
+	// value that represents all of the validation errors in the list.
+	//
+	// The Valids type is useful for collecting multiple validation errors
+	// and returning them as a single error value.
+
+	validate := func() error {
+		var b not.Valids
+		b.Add("name", "must be a valid name")
+		b.Add("email", "%q: must be a valid email address", "invalid.email")
+		return b
+	}
+
+	err := validate()
+	var nv not.Valids
+	if errors.As(err, &nv) {
+		for _, v := range nv {
+			fmt.Println(v)
+		}
+	}
+
+	// Output:
+	// invalid name: must be a valid name
+	// invalid email: "invalid.email": must be a valid email address
+}

app/ui/app.go

@@ -0,0 +1,44 @@
+//go:build windows || darwin
+
+package ui
+
+import (
+	"bytes"
+	"embed"
+	"errors"
+	"io/fs"
+	"net/http"
+	"strings"
+	"time"
+)
+
+//go:embed app/dist
+var appFS embed.FS
+
+// appHandler returns an HTTP handler that serves the React SPA.
+// It tries to serve real files first, then falls back to index.html for React Router.
+func (s *Server) appHandler() http.Handler {
+	// Strip the dist prefix so URLs look clean
+	fsys, _ := fs.Sub(appFS, "app/dist")
+	fileServer := http.FileServer(http.FS(fsys))
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p := strings.TrimPrefix(r.URL.Path, "/")
+		if _, err := fsys.Open(p); err == nil {
+			// Serve the file directly
+			fileServer.ServeHTTP(w, r)
+			return
+		}
+		// Fallback – serve index.html for unknown paths so React Router works
+		data, err := fs.ReadFile(fsys, "index.html")
+		if err != nil {
+			if errors.Is(err, fs.ErrNotExist) {
+				http.NotFound(w, r)
+			} else {
+				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			}
+			return
+		}
+		http.ServeContent(w, r, "index.html", time.Time{}, bytes.NewReader(data))
+	})
+}

app/ui/app/.gitignore

@@ -0,0 +1,30 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+.vite/
+.claude/
+
+*storybook.log
+storybook-static

app/ui/app/.prettierignore

@@ -0,0 +1 @@
+*.gen.ts

app/ui/app/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "all",
+  "semi": true,
+  "singleQuote": false,
+  "printWidth": 80
+}

app/ui/app/codegen/gotypes.gen.ts

@@ -0,0 +1,611 @@
+/* Do not change, this code is generated from Golang structs */
+
+
+export class ChatInfo {
+    id: string;
+    title: string;
+    userExcerpt: string;
+    createdAt: Date;
+    updatedAt: Date;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.id = source["id"];
+        this.title = source["title"];
+        this.userExcerpt = source["userExcerpt"];
+        this.createdAt = new Date(source["createdAt"]);
+        this.updatedAt = new Date(source["updatedAt"]);
+    }
+}
+export class ChatsResponse {
+    chatInfos: ChatInfo[];
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.chatInfos = this.convertValues(source["chatInfos"], ChatInfo);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class Time {
+
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+
+    }
+}
+export class ToolFunction {
+    name: string;
+    arguments: string;
+    result?: any;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.name = source["name"];
+        this.arguments = source["arguments"];
+        this.result = source["result"];
+    }
+}
+export class ToolCall {
+    type: string;
+    function: ToolFunction;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.type = source["type"];
+        this.function = this.convertValues(source["function"], ToolFunction);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class File {
+    filename: string;
+    data: number[];
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.filename = source["filename"];
+        this.data = source["data"];
+    }
+}
+export class Message {
+    role: string;
+    content: string;
+    thinking: string;
+    stream: boolean;
+    model?: string;
+    attachments?: File[];
+    tool_calls?: ToolCall[];
+    tool_call?: ToolCall;
+    tool_name?: string;
+    tool_result?: number[];
+    created_at: Time;
+    updated_at: Time;
+    thinkingTimeStart?: Date | undefined;
+    thinkingTimeEnd?: Date | undefined;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.role = source["role"];
+        this.content = source["content"];
+        this.thinking = source["thinking"];
+        this.stream = source["stream"];
+        this.model = source["model"];
+        this.attachments = this.convertValues(source["attachments"], File);
+        this.tool_calls = this.convertValues(source["tool_calls"], ToolCall);
+        this.tool_call = this.convertValues(source["tool_call"], ToolCall);
+        this.tool_name = source["tool_name"];
+        this.tool_result = source["tool_result"];
+        this.created_at = this.convertValues(source["created_at"], Time);
+        this.updated_at = this.convertValues(source["updated_at"], Time);
+        this.thinkingTimeStart = source["thinkingTimeStart"] && new Date(source["thinkingTimeStart"]);
+        this.thinkingTimeEnd = source["thinkingTimeEnd"] && new Date(source["thinkingTimeEnd"]);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class Chat {
+    id: string;
+    messages: Message[];
+    title: string;
+    created_at: Time;
+    browser_state?: BrowserStateData;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.id = source["id"];
+        this.messages = this.convertValues(source["messages"], Message);
+        this.title = source["title"];
+        this.created_at = this.convertValues(source["created_at"], Time);
+        this.browser_state = source["browser_state"];
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class ChatResponse {
+    chat: Chat;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.chat = this.convertValues(source["chat"], Chat);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class Model {
+    model: string;
+    digest?: string;
+    modified_at?: Time;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.model = source["model"];
+        this.digest = source["digest"];
+        this.modified_at = this.convertValues(source["modified_at"], Time);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class ModelsResponse {
+    models: Model[];
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.models = this.convertValues(source["models"], Model);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class InferenceCompute {
+    library: string;
+    variant: string;
+    compute: string;
+    driver: string;
+    name: string;
+    vram: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.library = source["library"];
+        this.variant = source["variant"];
+        this.compute = source["compute"];
+        this.driver = source["driver"];
+        this.name = source["name"];
+        this.vram = source["vram"];
+    }
+}
+export class InferenceComputeResponse {
+    inferenceComputes: InferenceCompute[];
+    defaultContextLength: number;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.inferenceComputes = this.convertValues(source["inferenceComputes"], InferenceCompute);
+        this.defaultContextLength = source["defaultContextLength"];
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class ModelCapabilitiesResponse {
+    capabilities: string[];
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.capabilities = source["capabilities"];
+    }
+}
+export class ChatEvent {
+    eventName: "chat" | "thinking" | "assistant_with_tools" | "tool_call" | "tool" | "tool_result" | "done" | "chat_created";
+    content?: string;
+    thinking?: string;
+    thinkingTimeStart?: Date | undefined;
+    thinkingTimeEnd?: Date | undefined;
+    toolCalls?: ToolCall[];
+    toolCall?: ToolCall;
+    toolName?: string;
+    toolResult?: boolean;
+    toolResultData?: any;
+    chatId?: string;
+    toolState?: any;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.eventName = source["eventName"];
+        this.content = source["content"];
+        this.thinking = source["thinking"];
+        this.thinkingTimeStart = source["thinkingTimeStart"] && new Date(source["thinkingTimeStart"]);
+        this.thinkingTimeEnd = source["thinkingTimeEnd"] && new Date(source["thinkingTimeEnd"]);
+        this.toolCalls = this.convertValues(source["toolCalls"], ToolCall);
+        this.toolCall = this.convertValues(source["toolCall"], ToolCall);
+        this.toolName = source["toolName"];
+        this.toolResult = source["toolResult"];
+        this.toolResultData = source["toolResultData"];
+        this.chatId = source["chatId"];
+        this.toolState = source["toolState"];
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class DownloadEvent {
+    eventName: "download";
+    total: number;
+    completed: number;
+    done: boolean;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.eventName = source["eventName"];
+        this.total = source["total"];
+        this.completed = source["completed"];
+        this.done = source["done"];
+    }
+}
+export class ErrorEvent {
+    eventName: "error";
+    error: string;
+    code?: string;
+    details?: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.eventName = source["eventName"];
+        this.error = source["error"];
+        this.code = source["code"];
+        this.details = source["details"];
+    }
+}
+export class Settings {
+    Expose: boolean;
+    Browser: boolean;
+    Survey: boolean;
+    Models: string;
+    Agent: boolean;
+    Tools: boolean;
+    WorkingDir: string;
+    ContextLength: number;
+    TurboEnabled: boolean;
+    WebSearchEnabled: boolean;
+    ThinkEnabled: boolean;
+    ThinkLevel: string;
+    SelectedModel: string;
+    SidebarOpen: boolean;
+    LastHomeView: string;
+    AutoUpdateEnabled: boolean;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.Expose = source["Expose"];
+        this.Browser = source["Browser"];
+        this.Survey = source["Survey"];
+        this.Models = source["Models"];
+        this.Agent = source["Agent"];
+        this.Tools = source["Tools"];
+        this.WorkingDir = source["WorkingDir"];
+        this.ContextLength = source["ContextLength"];
+        this.TurboEnabled = source["TurboEnabled"];
+        this.WebSearchEnabled = source["WebSearchEnabled"];
+        this.ThinkEnabled = source["ThinkEnabled"];
+        this.ThinkLevel = source["ThinkLevel"];
+        this.SelectedModel = source["SelectedModel"];
+        this.SidebarOpen = source["SidebarOpen"];
+        this.LastHomeView = source["LastHomeView"];
+        this.AutoUpdateEnabled = source["AutoUpdateEnabled"];
+    }
+}
+export class SettingsResponse {
+    settings: Settings;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.settings = this.convertValues(source["settings"], Settings);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class HealthResponse {
+    healthy: boolean;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.healthy = source["healthy"];
+    }
+}
+export class User {
+    id: string;
+    email: string;
+    name: string;
+    bio?: string;
+    avatarurl?: string;
+    firstname?: string;
+    lastname?: string;
+    plan?: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.id = source["id"];
+        this.email = source["email"];
+        this.name = source["name"];
+        this.bio = source["bio"];
+        this.avatarurl = source["avatarurl"];
+        this.firstname = source["firstname"];
+        this.lastname = source["lastname"];
+        this.plan = source["plan"];
+    }
+}
+export class Attachment {
+    filename: string;
+    data?: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.filename = source["filename"];
+        this.data = source["data"];
+    }
+}
+export class ChatRequest {
+    model: string;
+    prompt: string;
+    index?: number;
+    attachments?: Attachment[];
+    web_search?: boolean;
+    file_tools?: boolean;
+    forceUpdate?: boolean;
+    think?: any;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.model = source["model"];
+        this.prompt = source["prompt"];
+        this.index = source["index"];
+        this.attachments = this.convertValues(source["attachments"], Attachment);
+        this.web_search = source["web_search"];
+        this.file_tools = source["file_tools"];
+        this.forceUpdate = source["forceUpdate"];
+        this.think = source["think"];
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class Error {
+    error: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.error = source["error"];
+    }
+}
+export class ModelUpstreamResponse {
+    stale: boolean;
+    error?: string;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.stale = source["stale"];
+        this.error = source["error"];
+    }
+}
+export class Page {
+    url: string;
+    title: string;
+    text: string;
+    lines: string[];
+    links?: Record<number, string>;
+    fetched_at: Time;
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.url = source["url"];
+        this.title = source["title"];
+        this.text = source["text"];
+        this.lines = source["lines"];
+        this.links = source["links"];
+        this.fetched_at = this.convertValues(source["fetched_at"], Time);
+    }
+
+	convertValues(a: any, classs: any, asMap: boolean = false): any {
+	    if (!a) {
+	        return a;
+	    }
+	    if (Array.isArray(a)) {
+	        return (a as any[]).map(elem => this.convertValues(elem, classs));
+	    } else if ("object" === typeof a) {
+	        if (asMap) {
+	            for (const key of Object.keys(a)) {
+	                a[key] = new classs(a[key]);
+	            }
+	            return a;
+	        }
+	        return new classs(a);
+	    }
+	    return a;
+	}
+}
+export class BrowserStateData {
+    page_stack: string[];
+    view_tokens: number;
+    url_to_page: {[key: string]: Page};
+
+    constructor(source: any = {}) {
+        if ('string' === typeof source) source = JSON.parse(source);
+        this.page_stack = source["page_stack"];
+        this.view_tokens = source["view_tokens"];
+        this.url_to_page = source["url_to_page"];
+    }
+}

app/ui/app/eslint.config.js

@@ -0,0 +1,32 @@
+// For more info, see https://github.com/storybookjs/eslint-plugin-storybook#configuration-flat-config-format
+import storybook from "eslint-plugin-storybook";
+
+import js from "@eslint/js";
+import globals from "globals";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  { ignores: ["dist"] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      "react-hooks": reactHooks,
+      "react-refresh": reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      "react-refresh/only-export-components": [
+        "warn",
+        { allowConstantExport: true },
+      ],
+    },
+  },
+  storybook.configs["flat/recommended"],
+);

app/ui/app/index.html

@@ -0,0 +1,189 @@
+<!doctype html>
+<html lang="en" style="overflow: hidden">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="/src/index.css" />
+    <title>Ollama</title>
+  </head>
+  <body class="dark:bg-neutral-900 select-text">
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+    <script>
+      // Add selectFiles method if available
+      if (typeof window.selectFiles === "function") {
+        window.webview = window.webview || {};
+
+        // Single file selection (returns first file or null)
+        window.webview.selectFile = function () {
+          return new Promise((resolve) => {
+            window.__selectFilesCallback = (data) => {
+              window.__selectFilesCallback = null;
+              // For single file, return first file or null
+              resolve(data && data.length > 0 ? data[0] : null);
+            };
+            window.selectFiles();
+          });
+        };
+
+        // Multiple file selection (returns array or null)
+        window.webview.selectMultipleFiles = function () {
+          return new Promise((resolve) => {
+            window.__selectFilesCallback = (data) => {
+              window.__selectFilesCallback = null;
+              resolve(data); // Returns array of files or null if cancelled
+            };
+            window.selectFiles();
+          });
+        };
+      }
+
+      // Add directory selection methods if available
+      if (typeof window.selectModelsDirectory === "function") {
+        window.webview = window.webview || {};
+        window.webview.selectModelsDirectory = function () {
+          return new Promise((resolve) => {
+            window.__selectModelsDirectoryCallback = (path) => {
+              window.__selectModelsDirectoryCallback = null;
+              resolve(path); // Returns directory path or null if cancelled
+            };
+            window.selectModelsDirectory();
+          });
+        };
+      }
+
+      if (typeof window.selectWorkingDirectory === "function") {
+        window.webview = window.webview || {};
+        window.webview.selectWorkingDirectory = function () {
+          return new Promise((resolve) => {
+            window.__selectWorkingDirectoryCallback = (path) => {
+              window.__selectWorkingDirectoryCallback = null;
+              resolve(path); // Returns directory path or null if cancelled
+            };
+            window.selectWorkingDirectory();
+          });
+        };
+      }
+
+      if (typeof window.ready === "function") {
+        const callReady = () => setTimeout(window.ready, 100);
+        if (document.readyState === "complete") {
+          callReady();
+        } else {
+          window.addEventListener("load", callReady);
+        }
+      }
+
+      if (typeof window.resize === "function") {
+        window.addEventListener("resize", function () {
+          window.resize(window.innerWidth, window.innerHeight);
+        });
+      }
+
+      document.addEventListener("keydown", function (e) {
+        if (
+          e.key === "Backspace" &&
+          !e.target.matches("input, textarea, [contenteditable], select")
+        ) {
+          e.preventDefault();
+        }
+
+        // Only prevent navigation shortcuts when not in editable fields
+        if (!e.target.matches("input, textarea, [contenteditable], select")) {
+          // Prevent Cmd/Ctrl + Left/Right arrow navigation
+          if (
+            (e.ctrlKey || e.metaKey) &&
+            (e.key === "ArrowLeft" || e.key === "ArrowRight")
+          ) {
+            e.preventDefault();
+            return false;
+          }
+
+          // Prevent Alt + Left/Right arrow navigation (Windows/Linux)
+          if (e.altKey && (e.key === "ArrowLeft" || e.key === "ArrowRight")) {
+            e.preventDefault();
+            return false;
+          }
+        }
+
+        // Always prevent F5 refresh
+        if (e.key === "F5") {
+          e.preventDefault();
+          return false;
+        }
+
+        // Always prevent Ctrl/Cmd + Shift + R (hard refresh)
+        if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === "r") {
+          e.preventDefault();
+          return false;
+        }
+      });
+
+      // Prevent mouse button navigation (back/forward buttons)
+      document.addEventListener("mousedown", function (e) {
+        // Mouse button 3 is back, button 4 is forward
+        if (e.button === 3 || e.button === 4) {
+          e.preventDefault();
+          return false;
+        }
+      });
+
+      // Prevent drag and drop navigation
+      document.addEventListener("dragover", function (e) {
+        e.preventDefault();
+        return false;
+      });
+
+      document.addEventListener("drop", function (e) {
+        e.preventDefault();
+        return false;
+      });
+
+      // TODO (jmorganca): this is a way for different components to elect
+      // to show custom context menu items on top of the default one
+      // we should integrate this better since it's confusing to follow
+      document.addEventListener(
+        "contextmenu",
+        function (e) {
+          window.setContextMenuItems([]);
+          let target = e.target;
+          while (target && target !== document) {
+            if (
+              target.classList &&
+              target.classList.contains("allow-context-menu")
+            ) {
+              return true;
+            }
+            target = target.parentElement;
+          }
+          e.preventDefault();
+          return false;
+        },
+        true,
+      );
+
+      let pendingMenuItems = [];
+      let menuPromiseResolve = null;
+      let menuPromiseReject = null;
+
+      window.menu = function (items) {
+        return new Promise((resolve, reject) => {
+          pendingMenuItems = items;
+          menuPromiseResolve = resolve;
+          menuPromiseReject = reject;
+          window.setContextMenuItems(items);
+        });
+      };
+
+      window.handleContextMenuResult = function (selected) {
+        if (menuPromiseResolve) {
+          menuPromiseResolve(selected);
+          menuPromiseResolve = null;
+          menuPromiseReject = null;
+        }
+        pendingMenuItems = [];
+      };
+    </script>
+  </body>
+</html>

app/ui/app/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "app",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "prettier": "prettier --write .",
+    "prettier:check": "prettier --check .",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "@headlessui/react": "^2.2.4",
+    "@heroicons/react": "^2.2.0",
+    "@tanstack/react-query": "^5.80.7",
+    "@tanstack/react-router": "^1.120.20",
+    "@tanstack/react-router-devtools": "^1.120.20",
+    "clsx": "^2.1.1",
+    "framer-motion": "^12.17.0",
+    "katex": "^0.16.22",
+    "micromark-extension-llm-math": "^3.1.0",
+    "ollama": "^0.6.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "rehype-katex": "^7.0.1",
+    "rehype-prism-plus": "^2.0.1",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    "remark-math": "^6.0.0",
+    "streamdown": "^1.4.0",
+    "unist-builder": "^4.0.0",
+    "unist-util-parents": "^3.0.0"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^4.0.1",
+    "@eslint/js": "^9.25.0",
+    "@storybook/addon-a11y": "^9.0.14",
+    "@storybook/addon-docs": "^9.0.14",
+    "@storybook/addon-onboarding": "^9.0.14",
+    "@storybook/addon-vitest": "^9.0.14",
+    "@storybook/react-vite": "^9.0.14",
+    "@tailwindcss/typography": "^0.5.16",
+    "@tailwindcss/vite": "^4.1.11",
+    "@tanstack/router-plugin": "^1.120.20",
+    "@types/node": "^24.7.2",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@vitejs/plugin-react": "^4.4.1",
+    "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "autoprefixer": "^10.4.21",
+    "eslint": "^9.25.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-storybook": "^9.0.14",
+    "globals": "^16.0.0",
+    "playwright": "^1.53.2",
+    "postcss-preset-env": "^10.2.4",
+    "react-markdown": "^10.1.0",
+    "remark": "^15.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-stringify": "^11.0.0",
+    "storybook": "^9.0.14",
+    "tailwindcss": "^4.1.9",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vite": "^6.3.5",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4"
+  },
+  "overrides": {
+    "mdast-util-gfm-autolink-literal": "2.0.0"
+  }
+}

app/ui/app/public/launch-icons/claude-code.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>

app/ui/app/public/launch-icons/claude.svg

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated by Pixelmator Pro 3.6.17 -->
+<svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
+    <g id="g314">
+        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
+    </g>
+</svg>

app/ui/app/public/launch-icons/codex-dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>

app/ui/app/public/launch-icons/codex.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>

app/ui/app/public/launch-icons/copilot-dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z" fill="white"/></svg>

app/ui/app/public/launch-icons/copilot.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z"/></svg>

app/ui/app/public/launch-icons/hermes-agent.svg

@@ -0,0 +1,181 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="1000" viewBox="0 0 1000 1000"><circle cx="500.0" cy="500.0" r="500.0" fill="white"/><g transform="translate(100.0 100.0) scale(0.8333333333333334)"><g transform="translate(0.000000,960.000000) scale(0.100000,-0.100000)"
+fill="black" stroke="none">
+<path d="M4485 9589 c-248 -27 -432 -60 -730 -130 -458 -108 -798 -230 -1207
+-435 -533 -267 -1072 -675 -1358 -1030 -205 -255 -442 -748 -535 -1114 -108
+-426 -97 -870 29 -1160 73 -169 236 -369 381 -467 139 -94 425 -206 425 -167
+0 3 -26 32 -58 63 -74 71 -147 182 -184 278 -16 41 -27 77 -25 79 2 3 31 -28
+63 -68 91 -114 153 -177 231 -235 40 -29 77 -62 83 -73 7 -13 4 -85 -10 -242
+-10 -123 -24 -281 -30 -353 -6 -71 -29 -296 -51 -500 -135 -1262 -202 -1568
+-378 -1733 -69 -64 -105 -77 -216 -77 -132 0 -188 20 -271 97 -110 103 -165
+248 -167 438 -1 123 12 191 60 318 20 51 33 95 29 99 -10 10 -92 -74 -136
+-137 -153 -223 -204 -504 -146 -790 19 -91 97 -252 161 -333 112 -141 316
+-237 504 -237 180 0 419 118 591 290 81 81 107 115 196 255 50 78 54 56 13
+-71 -107 -337 -343 -577 -613 -625 -213 -39 -544 99 -707 295 -93 111 -133
+199 -173 381 -34 153 -34 154 -46 135 -15 -23 -12 -194 5 -305 42 -280 149
+-488 327 -636 133 -111 287 -195 465 -254 62 -20 115 -40 117 -44 3 -4 12 -43
+21 -87 44 -222 199 -385 416 -438 96 -24 265 -21 359 5 138 38 281 148 388
+297 39 55 48 63 50 45 4 -27 -38 -185 -78 -294 -80 -217 -176 -374 -312 -515
+-54 -55 -98 -104 -98 -107 0 -4 245 -7 545 -7 l544 0 126 66 c69 36 130 64
+135 62 6 -2 -10 -28 -34 -59 -46 -59 -48 -69 -10 -69 17 0 32 15 58 59 36 59
+51 71 87 71 23 0 25 -27 4 -77 -8 -19 -15 -39 -15 -44 0 -12 447 -11 470 1 10
+5 85 87 168 182 257 297 400 415 317 263 -16 -30 -26 -57 -23 -60 11 -12 210
+100 383 215 115 76 226 143 375 225 58 32 178 100 266 151 150 87 244 132 244
+117 0 -4 -78 -86 -174 -182 -207 -208 -246 -254 -334 -386 -48 -71 -122 -157
+-259 -298 -117 -120 -193 -206 -193 -217 0 -19 8 -20 115 -20 101 0 116 2 122
+18 19 54 112 249 156 327 124 221 283 436 369 502 87 67 225 152 337 209 103
+51 297 117 384 130 38 6 29 -2 -92 -75 -74 -45 -170 -107 -214 -139 -106 -76
+-247 -225 -332 -351 -67 -99 -70 -102 -79 -77 -6 14 -13 26 -18 26 -11 0 -57
+-75 -94 -155 -63 -136 -124 -376 -103 -401 15 -18 152 -19 166 -2 6 7 18 36
+27 63 23 72 66 131 217 301 302 339 430 464 590 577 148 104 233 128 520 148
+205 14 255 9 447 -38 118 -29 183 -65 298 -163 229 -195 538 -577 579 -715 24
+-83 71 -117 109 -79 9 8 16 27 16 42 0 62 -40 212 -73 277 -158 313 -551 635
+-922 755 -127 41 -142 55 -52 46 117 -11 231 -35 321 -65 158 -54 259 -123
+405 -277 164 -174 283 -379 322 -556 11 -51 25 -113 32 -137 36 -128 148 -81
+117 49 -14 60 -7 106 27 177 36 74 62 94 224 179 254 133 425 260 561 417 272
+315 403 732 358 1138 -24 218 -84 401 -179 545 -65 98 -155 203 -166 192 -3
+-3 7 -37 23 -75 136 -309 136 -725 2 -1063 -130 -330 -441 -760 -633 -879 -60
+-37 -60 -20 2 54 478 577 578 1337 315 2390 -25 99 -86 326 -136 505 -169 611
+-386 1539 -494 2109 -161 857 -200 998 -442 1606 -161 405 -321 692 -529 950
+-93 114 -322 343 -433 431 -203 160 -497 332 -737 428 -293 118 -702 220 -978
+246 -129 12 -406 11 -520 -1z m-267 -214 c301 -47 596 -191 852 -419 85 -76
+266 -270 345 -371 294 -376 520 -873 640 -1409 45 -199 45 -222 3 -244 -18 -9
+-45 -30 -61 -45 -25 -23 -28 -33 -23 -60 9 -44 21 -54 121 -98 91 -40 225
+-124 225 -140 0 -9 -33 5 -211 89 -126 60 -159 94 -167 173 -5 50 14 89 43 89
+26 0 65 49 65 81 0 52 -22 110 -48 127 -23 15 -37 14 -186 -7 -172 -25 -210
+-36 -240 -69 -23 -27 -31 -99 -14 -131 16 -29 30 -37 85 -51 26 -7 44 -17 48
+-29 10 -32 -15 -153 -41 -197 -27 -49 -131 -161 -139 -152 -9 9 36 77 85 126
+23 24 48 60 56 79 13 31 13 38 -3 71 -10 20 -29 42 -43 48 -14 7 -37 18 -52
+24 -33 15 -42 39 -63 155 -24 133 -90 393 -135 532 -119 367 -287 686 -483
+919 -175 208 -434 427 -659 557 -229 131 -498 197 -804 197 -136 0 -185 -4
+-313 -26 -87 -14 -31 14 137 70 186 61 289 89 437 117 120 23 376 20 543 -6z
+m2913 -962 c50 -53 113 -138 198 -268 76 -116 60 -104 -41 32 -34 46 -63 81
+-66 79 -2 -2 2 -30 9 -63 9 -44 9 -86 1 -171 -6 -63 -13 -116 -16 -119 -3 -4
+-15 2 -26 12 -32 29 -34 12 -5 -57 50 -118 66 -160 62 -164 -2 -2 -29 34 -61
+81 -31 47 -61 83 -66 80 -6 -4 -7 -24 -4 -47 7 -39 6 -40 -14 -27 -12 7 -25
+10 -29 5 -17 -17 -4 -106 31 -210 20 -60 35 -111 33 -112 -2 -2 -30 43 -62 99
+-60 102 -173 233 -182 210 -2 -7 26 -82 62 -168 37 -85 65 -160 63 -166 -2 -6
+-43 66 -91 160 -63 121 -93 171 -106 171 -9 0 -37 -21 -61 -46 -55 -56 -56
+-56 -248 20 -78 31 -156 59 -172 63 l-30 6 24 -54 c13 -30 51 -114 85 -188 34
+-73 60 -135 58 -137 -2 -3 -21 24 -42 58 -56 91 -85 128 -102 128 -13 0 -14
+-8 -9 -42 l7 -42 -83 80 c-109 106 -163 133 -260 126 -35 -3 -38 0 -53 34 -9
+21 -13 44 -11 51 7 17 58 16 147 -2 101 -21 104 -17 92 106 -6 52 -7 98 -3
+102 4 5 25 -20 47 -55 22 -35 47 -68 54 -75 18 -14 278 -83 316 -83 23 0 42
+13 86 59 61 64 64 72 42 111 -19 33 -19 54 0 46 11 -4 23 6 37 30 l21 35 66
+-3 66 -3 -2 29 c-1 16 -25 63 -52 105 -28 41 -49 77 -47 78 2 2 47 -42 101
+-97 75 -76 105 -100 125 -100 14 0 35 -7 47 -15 20 -14 22 -14 27 2 3 10 6 72
+7 138 2 102 -1 128 -19 175 -12 30 -22 56 -22 58 0 9 40 -22 71 -55z m-2642
+-139 c29 -35 60 -64 67 -64 8 0 52 27 97 61 l82 60 47 -51 c59 -63 161 -218
+218 -327 23 -46 48 -83 55 -83 8 0 26 5 41 11 49 18 73 4 104 -64 33 -70 48
+-127 33 -127 -6 0 -32 9 -58 21 -28 12 -56 18 -71 15 -21 -6 -27 1 -55 56 -67
+132 -208 340 -244 361 -10 5 -19 -1 -29 -22 -29 -55 -35 -106 -20 -183 8 -40
+14 -74 14 -75 0 -1 -12 2 -26 8 l-27 10 7 -62 c6 -61 6 -62 -14 -44 -15 14
+-31 17 -72 13 -58 -6 -88 -32 -88 -76 l0 -26 -29 34 c-29 35 -30 35 -122 38
+-52 2 -99 8 -106 14 -15 12 -83 132 -83 146 0 6 23 39 50 73 56 70 68 99 52
+134 -12 27 -15 25 81 46 65 14 68 21 42 105 -26 85 -18 85 54 -2z m-397 -294
+c84 -126 196 -352 237 -475 33 -99 28 -115 -23 -66 -45 44 -55 29 -49 -77 5
+-95 -4 -97 -33 -7 -22 67 -52 125 -64 125 -6 0 -10 -39 -11 -92 0 -51 -4 -101
+-8 -111 -9 -23 -10 -22 -85 101 -32 50 -62 92 -68 92 -7 0 -9 -22 -4 -70 6
+-74 -3 -90 -24 -40 -21 50 -33 54 -87 30 -26 -11 -57 -30 -69 -41 -20 -19 -21
+-19 -75 10 -30 17 -91 41 -137 54 -46 13 -89 30 -97 38 -16 16 -45 142 -36
+157 3 5 58 33 121 61 l114 51 21 -26 21 -26 49 39 c51 40 69 66 80 116 5 23
+10 28 32 25 19 -2 28 -11 37 -38 37 -115 42 114 6 250 -45 171 -47 164 22 90
+33 -36 92 -112 130 -170z m-1789 73 c-3 -10 -32 -77 -63 -148 -48 -109 -137
+-340 -242 -628 -11 -32 -22 -56 -24 -54 -2 2 -9 32 -14 68 -24 141 -20 131
+-47 124 -13 -3 -50 -18 -81 -33 -43 -20 -62 -37 -79 -67 -32 -59 -40 -65 -88
+-65 -55 0 -56 6 -16 106 29 75 176 339 194 351 12 7 14 14 -47 -125 -25 -56
+-46 -113 -46 -127 0 -25 0 -25 35 -11 109 46 179 120 301 316 135 217 241 360
+217 293z m-869 -35 c-4 -7 -33 -49 -64 -93 -140 -200 -268 -431 -368 -665
+-114 -268 -153 -314 -74 -86 41 115 44 129 29 137 -28 16 -39 80 -22 128 27
+77 98 202 139 246 58 61 355 345 362 345 3 0 2 -6 -2 -12z m1415 -533 l1 -130
+-23 39 c-26 47 -41 51 -45 14 -4 -36 -18 -35 -37 1 -8 17 -19 32 -25 36 -5 3
+-60 -10 -122 -30 -76 -25 -130 -36 -165 -36 -29 1 -82 -5 -118 -14 -99 -23
+-109 -21 -149 29 -20 23 -36 50 -36 58 0 12 55 182 75 231 11 27 38 21 147
+-34 76 -38 108 -49 130 -45 21 4 28 2 28 -9 0 -10 11 -15 34 -15 45 0 153 34
+177 56 10 9 35 69 55 133 56 180 58 180 65 1 4 -85 7 -213 8 -285z m-1394 272
+c-31 -55 -32 -83 -2 -91 47 -12 65 -6 97 34 18 23 34 39 36 38 2 -2 -20 -48
+-48 -102 l-50 -99 33 7 c84 17 149 19 149 5 0 -8 -37 -104 -82 -213 -74 -177
+-83 -195 -86 -162 -4 50 -26 56 -66 17 -17 -17 -35 -31 -39 -31 -4 0 -7 18 -7
+40 0 28 -6 43 -18 51 -15 10 -18 21 -14 65 8 93 -18 69 -89 -80 -35 -74 -65
+-133 -67 -131 -3 2 5 35 17 74 11 38 21 74 21 80 0 6 -35 11 -87 13 l-88 3 3
+30 c4 42 162 364 187 381 11 8 44 14 76 14 55 0 59 2 93 42 20 23 36 45 36 50
+0 4 5 8 10 8 6 0 -1 -20 -15 -43z m1710 6 c120 -17 143 -19 164 -12 10 3 21
+-17 37 -67 24 -77 75 -306 69 -312 -2 -2 -21 14 -43 37 l-39 41 -145 0 c-128
+0 -148 2 -170 19 -16 13 -29 17 -39 10 -8 -5 -17 -9 -20 -9 -10 0 -66 178 -74
+232 -4 25 -4 56 0 68 7 21 11 22 79 16 39 -4 121 -14 181 -23z m-79 -988 c74
+-190 129 -303 247 -514 76 -136 79 -145 62 -157 -24 -17 -76 -18 -98 -1 -21
+16 -126 237 -165 347 -30 87 -143 516 -141 541 1 19 17 -19 95 -216z m3644 61
+c64 -163 185 -534 301 -926 66 -223 147 -490 179 -595 175 -566 250 -858 321
+-1240 22 -121 43 -231 46 -245 4 -18 3 -22 -6 -15 -6 6 -22 71 -36 145 -58
+313 -100 487 -200 820 -40 135 -94 317 -120 405 -161 550 -413 1387 -465 1540
+-55 165 -67 205 -56 194 2 -2 18 -39 36 -83z m-4395 -812 c61 -60 129 -118
+149 -128 46 -22 69 -19 238 25 70 18 130 30 133 27 3 -3 -19 -42 -49 -87 -53
+-78 -75 -125 -63 -137 14 -14 111 32 205 96 57 38 136 85 176 104 84 40 299
+116 327 116 12 0 37 -24 66 -65 25 -36 54 -67 62 -69 9 -2 178 -1 376 2 l360
+7 10 70 c10 68 10 69 22 40 7 -16 17 -49 23 -73 14 -53 18 -55 187 -82 178
+-28 191 -33 200 -78 12 -57 8 -612 -6 -742 -17 -170 -53 -395 -141 -880 -206
+-1142 -248 -1540 -194 -1863 8 -49 12 -97 9 -107 -8 -24 -195 -200 -213 -200
+-7 0 -21 14 -30 31 -140 256 -353 528 -467 594 -66 39 -95 39 -361 1 -137 -19
+-303 -40 -368 -47 -128 -12 -307 -7 -368 11 -54 16 -140 78 -185 132 -41 51
+-348 610 -438 801 -105 220 -178 478 -191 667 -7 97 11 328 25 343 5 5 23 -17
+41 -49 18 -32 72 -97 125 -148 54 -53 97 -104 101 -120 12 -50 -1 -119 -34
+-170 -22 -33 -32 -62 -32 -88 0 -45 31 -126 70 -182 23 -35 28 -50 23 -82 -3
+-24 4 -70 17 -119 18 -68 28 -87 68 -128 59 -60 118 -101 132 -92 6 4 10 18 8
+32 -3 22 3 28 48 44 28 11 59 28 70 40 l18 20 -107 -7 c-118 -8 -146 0 -166
+43 -17 37 -14 52 18 84 33 33 78 41 66 12 -14 -31 -16 -77 -5 -93 9 -13 14
+-11 36 14 21 24 25 37 21 68 -5 37 -4 38 36 49 56 15 192 6 242 -15 l40 -17
+-27 -20 c-66 -49 -1 -50 120 -2 80 31 92 40 92 64 0 33 -30 52 -72 45 -33 -5
+-51 1 -140 49 -226 121 -267 139 -327 139 -31 1 -68 -3 -83 -8 -24 -7 -32 -3
+-62 30 -62 67 -63 76 -30 145 53 111 38 151 -110 308 -88 93 -131 162 -142
+230 -11 67 0 84 99 164 142 113 222 232 261 384 46 178 -18 329 -188 441 -74
+48 -75 49 -51 60 35 16 31 28 -20 64 -31 22 -41 34 -32 40 21 14 168 59 252
+77 67 15 80 21 83 39 2 12 -33 92 -82 187 -100 193 -117 263 -35 144 28 -41
+102 -124 164 -185z m-430 -364 c-13 -21 19 -51 100 -97 78 -43 142 -93 119
+-93 -5 0 -34 7 -64 15 -69 19 -148 19 -180 0 -24 -14 -24 -14 21 -15 63 0 238
+-37 267 -56 24 -16 42 -52 42 -85 0 -17 -8 -14 -57 24 -92 71 -138 91 -213 90
+-36 0 -85 -8 -109 -17 -55 -20 -64 -14 -103 71 -37 82 -36 104 4 127 60 36
+190 63 173 36z m4328 -154 c76 -37 148 -103 127 -116 -27 -17 -107 -10 -174
+15 -91 34 -212 35 -310 1 -55 -19 -76 -22 -100 -14 -17 5 -37 12 -45 14 -17 6
+18 45 66 75 76 47 131 59 258 57 109 -3 125 -6 178 -32z m-4293 -282 c3 -28
+11 -58 17 -66 7 -8 12 -30 12 -49 -1 -40 10 -72 46 -128 33 -53 32 -67 -5 -80
+-78 -27 -118 37 -133 210 -10 105 -9 120 7 144 27 42 50 29 56 -31z m-53 -438
+c-4 -9 -11 -16 -17 -16 -11 0 -14 33 -3 44 11 10 26 -11 20 -28z m449 -922
+c60 -20 62 -23 44 -34 -23 -15 -104 -12 -126 5 -19 15 -19 15 0 30 24 18 22
+19 82 -1z m5843 -211 c82 -179 180 -472 218 -653 34 -160 38 -387 10 -517 -37
+-172 -107 -345 -191 -471 -81 -122 -215 -266 -232 -249 -2 2 10 37 27 78 188
+447 261 1077 185 1584 -15 98 -31 196 -35 217 -10 44 0 50 18 11z m-2689 -313
+c25 -333 24 -319 22 -342 -1 -10 -66 -56 -164 -115 -175 -106 -203 -121 -196
+-101 3 7 26 81 53 163 39 124 214 633 241 699 15 37 22 -12 44 -304z m110
+-832 c37 -172 37 -173 -56 -257 -80 -73 -143 -103 -230 -109 -105 -7 -132 9
+-183 108 -53 101 -53 132 -3 177 21 19 126 88 233 153 182 111 194 117 201 97
+3 -12 20 -88 38 -169z m-1046 -650 c67 -151 141 -236 331 -383 138 -106 239
+-173 309 -204 42 -18 47 -23 36 -36 -7 -9 -110 -81 -229 -160 -178 -118 -251
+-161 -416 -238 -110 -51 -250 -117 -312 -147 -62 -29 -118 -50 -126 -47 -7 3
+-24 34 -36 69 -28 77 -74 158 -252 445 -75 122 -140 231 -144 242 -6 19 -2 21
+42 21 63 0 171 24 230 50 35 15 99 72 238 209 182 180 271 261 285 261 4 0 24
+-37 44 -82z m-2387 -88 c-10 -81 -64 -284 -102 -378 -55 -136 -119 -238 -204
+-323 -108 -107 -162 -132 -306 -137 -109 -4 -111 -3 -175 30 -42 22 -76 48
+-98 78 l-35 45 114 7 c338 22 478 105 645 383 29 50 70 131 89 180 49 124 67
+165 73 165 3 0 2 -22 -1 -50z m1647 -1402 c-54 -78 -300 -358 -315 -358 -16 0
+-10 15 29 76 113 173 323 408 330 370 2 -10 -18 -49 -44 -88z"/>
+<path d="M3229 5845 c-108 -15 -150 -30 -198 -71 -49 -41 -111 -123 -111 -146
+0 -18 5 -20 40 -15 22 3 40 3 40 1 0 -2 -9 -26 -20 -53 -12 -32 -16 -52 -9
+-56 9 -6 7 -23 -8 -62 -3 -8 4 -13 20 -13 16 0 26 -7 30 -20 8 -30 33 -24 48
+12 15 37 122 148 142 148 12 0 11 -10 0 -56 -17 -66 -10 -118 17 -137 15 -11
+19 -21 14 -44 -5 -25 2 -39 44 -90 28 -33 66 -67 85 -76 39 -19 112 -22 152
+-7 39 15 108 74 140 121 27 38 28 41 13 72 -15 32 -15 34 8 54 13 12 24 33 24
+47 l0 25 38 -17 c58 -26 111 -62 122 -81 6 -13 3 -29 -11 -57 -98 -186 -404
+-264 -685 -174 -101 32 -143 37 -162 18 -21 -21 -13 -28 31 -28 49 0 82 -19
+91 -53 5 -20 11 -23 31 -19 14 2 31 0 38 -6 17 -14 145 -34 168 -27 11 4 26 1
+34 -5 9 -7 23 -9 37 -4 13 5 41 9 63 11 22 1 51 3 65 4 14 1 37 -1 52 -5 21
+-6 27 -4 33 13 5 18 14 21 55 21 43 0 49 3 52 23 3 19 10 22 51 25 49 3 53 7
+37 32 -11 17 4 30 38 30 15 0 22 6 22 19 0 14 16 27 55 45 40 18 56 31 61 51
+3 14 16 32 27 40 18 13 20 18 10 34 -11 17 -8 21 25 35 100 44 116 63 55 68
+-33 3 -38 6 -36 26 3 22 0 22 -45 16 -44 -6 -49 -4 -83 29 -58 56 -354 199
+-469 227 -116 28 -147 43 -70 36 30 -3 108 -23 173 -45 64 -22 117 -36 117
+-31 0 13 -23 24 -160 75 -142 53 -197 60 -331 40z"/>
+<path d="M3027 5303 c-3 -5 -2 -15 2 -22 7 -10 10 -10 16 -1 4 6 3 16 -3 22
+-5 5 -12 6 -15 1z"/>
+<path d="M2180 4462 c0 -11 136 -122 149 -122 19 0 12 46 -11 75 -12 15 -36
+34 -54 41 -37 15 -84 19 -84 6z"/>
+</g></g></svg>

app/ui/app/public/launch-icons/openclaw.svg

@@ -0,0 +1,242 @@
+<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500" width="500" height="500">
+	<style>
+		.s0 { fill: #f6f4f4 } 
+		.s1 { fill: #0b0303 } 
+		.s2 { fill: #ef0011 } 
+		.s3 { fill: #f3e2e2 } 
+		.s4 { fill: #f00212 } 
+		.s5 { fill: #ba000d } 
+		.s6 { fill: #faf1f1 } 
+		.s7 { fill: #0b0100 } 
+		.s8 { fill: #fbedee } 
+		.s9 { fill: #faeaea } 
+		.s10 { fill: #ab797d } 
+		.s11 { fill: #f8eaea } 
+		.s12 { fill: #902021 } 
+		.s13 { fill: #f9eeee } 
+		.s14 { fill: #f6ecec } 
+		.s15 { fill: #080201 } 
+		.s16 { fill: #150100 } 
+		.s17 { fill: #f2e7e7 } 
+		.s18 { fill: #fbe7e8 } 
+		.s19 { fill: #060101 } 
+		.s20 { fill: #f5e7e7 } 
+		.s21 { fill: #fa999e } 
+		.s22 { fill: #c46064 } 
+		.s23 { fill: #180300 } 
+		.s24 { fill: #f6dcdd } 
+		.s25 { fill: #f2e6e6 } 
+		.s26 { fill: #110200 } 
+		.s27 { fill: #eb0011 } 
+		.s28 { fill: #e20010 } 
+		.s29 { fill: #ea0011 } 
+		.s30 { fill: #760007 } 
+		.s31 { fill: #f00514 } 
+		.s32 { fill: #fcebeb } 
+		.s33 { fill: #ecd6d6 } 
+		.s34 { fill: #f5e3e3 } 
+		.s35 { fill: #f5e4e4 } 
+		.s36 { fill: #faf6f6 } 
+		.s37 { fill: #e50010 } 
+		.s38 { fill: #d5000f } 
+		.s39 { fill: #f2e2e3 } 
+		.s40 { fill: #ef1018 } 
+		.s41 { fill: #f4e8e9 } 
+		.s42 { fill: #ef0513 } 
+		.s43 { fill: #f5e5e5 } 
+		.s44 { fill: #f00413 } 
+		.s45 { fill: #f4e9ea } 
+		.s46 { fill: #ed0011 } 
+		.s47 { fill: #e80011 } 
+		.s48 { fill: #e60613 } 
+		.s49 { fill: #f0d6d6 } 
+		.s50 { fill: #fca9ac } 
+		.s51 { fill: #9c000c } 
+		.s52 { fill: #73393b } 
+	</style>
+	<g>
+		<path fill-rule="evenodd" class="s0" d="m166.5 52.5q3.5 0 7 0 2.75 2.99 1.5 7-21.27 45.61-20.5 96 39.99 2.76 72 26.5 7.87 6.86 13.5 15.5 42.88-56.39 103.5-92.5 47.35-25.46 101-25 14.52 0.38 23.5 11.5 3.19 7.74 2 16-1.81 7.18-4.5 14-1 0-1 1-5.04 6.05-9 13-1 0-1 1 0 0.5 0 1-12.42 12.15-28.5 19-6.02 36.27-41.5 45-0.83 2.75 0 5 19.02-12.85 41.5-9 10.85-8.09 23.5-13 15.01-6.37 31-2.5 14.09 7.43 14 23.5-2.83 23.25-15.5 43-6.42 9.92-14 19-10.04 8.8-19.5 18-72.02 48.88-156.5 27-19.63 9.6-41.5 10.5-4.59 1.27-9 3 2 1 4 2 20.09-1.11 35 12 25.46 6.95 37.5 30.5 1.26 5.69-1 11-3.38 3.79-7.5 6.5 5.74 10.07 1.5 20.5-7.55 7.47-17.5 3.5-11.01-5.34-22.5-9.5-18.26 10-38.5 13-15.5 0-31 0-26.62-4.54-51-17-4.17 1.33-8 3.5-7.23 5.87-15 11-8.62 2.58-13.5-4.5-1.82 2.32-4.5 3.5-6.06 2.24-12 3.5-7.5 0-15 0-27.42-2.56-50-18.5-18-17.25-23-41.5 0-11.5 0-23 4.12-22.7 25-33 6.95-16.67 22-26.5-20.39-20.8-14.5-49.5 7.01-26.98 28.5-44.5 7.56-5.27 15-10.5-13.09-30.88-7.5-64 3.16-15.57 14.5-26.5 6.85-2.48 8 4.5-6.59 39.53 11 75.5 7.99-0.49 16-2 2.42-34.57 14.5-67.5 8.51-22.23 27.5-36z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s1" d="m113.5 401.5q0.48-5.1-1-10-0.91 0.19-1 1-2.46 1.74-5 3.5 5.65 9.54-5 13-32.21 5.55-61-10-32.89-23.11-29.5-63.5 2.96-22.67 23.5-32 7.99-19.75 27-29.5-27.65-23.7-15.5-58.5 7.33-16.82 20.5-29.5 10.79-8.14 22-15.5-16.49-37.08-5.5-76 3.19-6.13 7.5-11.5 1.48-0.89 2 1-5.69 41.09 12.5 78.5 1 1 2 2 9.97-3.24 20.5-4 2 0 4 0 0-7.5 0-15 0.99-42.22 24.5-77 6.12-7.12 14-12-4.65 13.43-10 27-11.93 37.6-9.5 77 49.38 0.7 83.5 36 2.75 4.5 5.5 9 38.99-52.24 93-88.5 45.84-29.03 100-32.5 15.69-1.56 29 6.5 5.68 7.29 3.5 16.5-10.38 33.62-43.5 45-4.39 37.33-41 45-0.79 8.63-6 15.5 1.91 1.83 4.5 2.5 22.27-17.25 50.5-14.5 12.93-9.41 28-15 36.22-8.28 31.5 28.5-15.19 51.69-62.5 77.5-65.92 35.87-138 15.5-19.67 10.42-42 10.5-8.39 2.88-17 5 3.58 6.08 10 9 20.92-1.14 36 13 22.67 5.23 34.5 25.5 3.33 7.13-3.5 11.5-3.88 1.8-8 3 7.36 8.45 6.5 19.5-4.43 5.66-11.5 3.5-12.84-5.67-26-10.5-39.4 21.02-83 10.5-18.85-5.78-36.5-14.5-13.65 4.14-23.5 14.5-9.51 3.74-11-6.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s2" d="m153.5 173.5q24.62 1.46 46 13.5 12.11 8.1 17.5 21.5 0.74 2.45 0.5 5 0.09 0.81 1 1 1.48-4.9 1-10 5.04 10.48 1.5 22-9.81 27.86-35.5 42.5-26.17 14.97-56 19.5-2.77-0.4-2 1 2.86 1.27 6 1 25.64 1.53 48.5-10 0.34 10.08 2 20 1.08 5.76 5 10 1 1.5 0 3-31.11 20.84-68.5 17.5-23.7-5.7-32.5-28.5-4.39-9.18-3.5-19 15.41 6.23 32 4.5-20.68-6.39-39-18-34.81-27.22-12.5-65.5 11.84-14.83 29-23 4.21 7.66 11.5 12.5 3 1 6 0-26.04-34.62-29-78-0.13-8.46 2-16.5 1 6.5 2 13 3.43 39.53 24.5 73 2.03 2.28 4.5 4 0.5-1.25 1-2.5-1.27-6.54-5-12 0.5-0.75 1-1.5 9.72-3.43 20-4 0.55 10.34 8 17.5 1.94 0.74 4 0.5-17.8-64.6 16.5-122 0.98-1.79 1.5 0-28.21 56.64-13.5 118 1.08 1.43 2.5 0.5 2.21-4.98 2-10.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s3" d="m454.5 97.5q-18.37-2.97-37-1.5-16.14 2.08-32 5.5 32.38-14.09 67-7.5 1.98 1.22 2 3.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s4" d="m454.5 97.5q-1.33 11.18-8.5 20-21.81 26.28-55.5 32-1.11-0.2-2 0.5 2.31 2.82 5.5 4.5 1 2 0 4-9.56 11.3-19.5 20 19.71-8.72 31-27 2.68-0.43 5 1-14.24 30.97-48 36.5-9.93 1.71-20 1.5-6.8-0.48-13 1 5.81 6.92 14 11-10.78 16.03-27 26.5 27.16-7.4 38-33.5 4.34 1.35 9 1-9.08 23.84-33 33.5-18.45 6.41-38 7 22.59 8.92 45-1 12.05-5.52 24-11 9.01-1.79 17 2.5 5.28-4.38 11-8 12.8-6.07 27-5 0 0.5 0 1-19.34 2.69-34 15.5 0.5 0.25 1 0.5 17.79-8.09 36-15 2.71-0.79 5-2 2.5-1 5-2 5.53-4.04 11-8 11.7-4.18 24-6.5 7.78-1.36 15 1.5-2.97 18.45-13.5 34-34.92 49.37-94.5 62.5-59.27 12.45-108-23-15.53-12.52-21.5-31.5-2.47-14.26 4-27-3.15 24.41 14 42-4.92-10.28-7-22-1.97-17.63 7-33 47.28-69.5 125.5-100 15.86-3.42 32-5.5 18.63-1.47 37 1.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s5" d="m86.5 112.5q-1-6.5-2-13 0.7-5.34 3.5-10-1.8 11.32-1.5 23z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s6" d="m433.5 97.5q2.22-0.39 4 1-10 13.75-27 14-0.24-2.06 0.5-4 10.3-7.78 22.5-11z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s7" d="m407.5 101.5q2.55-0.24 5 0.5-52.87 18.31-84.5 64.5-6.94 7.95-17 11-9.38-2.38-5-11 40.38-48.62 101.5-65z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s8" d="m402.5 112.5q3 0 6 0-2.56 8.8-12 7-0.22-1.58 0.5-3 2.72-2.22 5.5-4z"/>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s9" d="m390.5 149.5q7.77 0.52 15 2-11.29 18.28-31 27 9.94-8.7 19.5-20 1-2 0-4-3.19-1.68-5.5-4.5 0.89-0.7 2-0.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s10" d="m131.5 145.5q0 7.5 0 15-2 0-4 0 1.06-1.36 3-1-0.48-7.29 1-14z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s11" d="m219.5 204.5q-1 4.5-2 9 0.24-2.55-0.5-5-5.39-13.4-17.5-21.5-21.38-12.04-46-13.5 0-2 0-4 36.7-0.86 61.5 26 3.06 4.11 4.5 9z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s12" d="m329.5 191.5q6.2-1.48 13-1-3.5 1-7 2-2.9-0.97-6-1z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s13" d="m329.5 191.5q3.1 0.03 6 1 9.55 1.31 19 3-10.84 26.1-38 33.5 16.22-10.47 27-26.5-8.19-4.08-14-11z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s14" d="m479.5 199.5q-7.22-2.86-15-1.5-12.3 2.32-24 6.5 15.6-13.11 36-11.5 3.63 2.26 3 6.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s15" d="m193.5 216.5q-12.01 1.52-22 8-2.83 1.29-5.5 3-4.79-4.57-6.5-11-5.04 2.2-9.5-1-3.47-6.4 3.5-3 4.4 0.05 8-2.5 9.22-9.73 21-16 6.3-3.24 12 1-2.9 1.22-6 1.5 2.61 5.74 4.5 12 0.75 3.97 0.5 8z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s16" d="m458.5 200.5q3.04-0.24 6 0.5-18.02 7.05-33 19-1 1-2 0 11.53-14.3 29-19.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s17" d="m178.5 202.5q6.85-0.63 4.5 6-7.6 5.09-6-4 1.08-0.82 1.5-2z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s18" d="m469.5 201.5q-2.26 13.65-14.5 22-0.47-2.11 1-4 7.08-8.82 13.5-18z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s19" d="m74.5 208.5q8.22-0.2 16 2.5 11.8 4.26 23.5 8.5 5.65-0.63 8-6 2.41 11.83-9.5 13 0.55 3.61 2 7-0.5 1-1 2-4.67-0.94-9.5-1-9.96 0.44-19.5 2.5-5.05-3.55-6.5-9.5-0.75-7.48-0.5-15-6.47 0.15-3-4z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s20" d="m429.5 212.5q-2.5 1-5 2-4 0-8 0-14.2-1.07-27 5 15.27-12.44 35-9.5 2.72 1.14 5 2.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s21" d="m219.5 204.5q0.48 5.1-1 10-0.91-0.19-1-1 1-4.5 2-9z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s22" d="m416.5 215.5q0-0.5 0-1 4 0 8 0-2.29 1.21-5 2-1.06-1.36-3-1z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s23" d="m416.5 215.5q1.94-0.36 3 1-18.21 6.91-36 15-0.5-0.25-1-0.5 14.66-12.81 34-15.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s24" d="m193.5 216.5q4.39 1.3 9 3-0.79 1.04-2 1.5-14.77-0.13-29 3.5 9.99-6.48 22-8z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s25" d="m98.5 219.5q6.09-0.98 6 5-3.04 0.24-6-0.5-1.84-2.24 0-4.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s26" d="m176.5 229.5q8.85-1.14 16 4-4.98 1.75-10 0-13.56 14.3-33 19.5-28.06 8.2-55 1 3.32-6.4 10-5.5-0.71 1.47-2 2.5 36.58 4.24 69-14 4.68-2.13 1-5 2.35-0.91 4-2.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s27" d="m231.5 238.5q1.31-0.2 2 1-3.13 28.62 15 51-16.25 6.75-27-7.5-1-1-2 0 14.73 29.34 46 18.5 1.79 0.52 0 1.5-37.63 16.82-50.5-22.5-5.1-26.48 16.5-42z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s28" d="m243.5 259.5q5.88 3.62 10.5 9 12.96 18.46 32.5 29.5-31.51-7.75-43-38.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s29" d="m203.5 266.5q1.31-0.2 2 1-2.48 22.08 12 39-6.99 1.35-14 0.5 4.59 4.08 10 7-8.71 0.28-14.5-6.5-16.98-22.76 4.5-41z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s27" d="m58.5 284.5q9.6-2.17 14.5 6 5.15 14.18-1 28-11.05-13.14-27.5-17.5 5.15-9.9 14-16.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s30" d="m129.5 288.5q2 1 4 2-3.14 0.27-6-1-0.77-1.4 2-1z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s31" d="m56.5 313.5q3.43 5.43 8 10-4.88 0.44-8 4-1.11-0.2-2 0.5 28.91 1.65 38 28.5 0.45 3.16-1 6-11.02-7.01-23-12.5-4.75-3.75-9.5-7.5 1.47 7.42 7 13 8.34 27.18 32 43 0.99 2.41-1.5 3.5-40.25 5.58-66.5-25.5-15.67-22.01-8-48 10.46-23.87 34.5-15z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s32" d="m45.5 317.5q4.03-0.25 8 0.5 2.46 4.16-2 6-6.04 2.01-9-3.5 1.26-1.85 3-3z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s33" d="m56.5 313.5q4.91 3.14 9.5 7 0.88 2.25-1.5 3-4.57-4.57-8-10z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s34" d="m198.5 319.5q-11.1 11.56-27 15.5-15.75 4.88-32 2.5 28.81-3.69 54-18.5 2.65-0.96 5 0.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s4" d="m198.5 319.5q1.44 0.68 2.5 2 2.41 8.23 6 16 1.2 2.64-0.5 5-30.65 21.41-68 18.5-25.16-6.17-32.5-30.5 6.96 4.99 15.5 6.5 8.99 0.75 18 0.5 16.25 2.38 32-2.5 15.9-3.94 27-15.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s35" d="m92.5 356.5q-9.09-26.85-38-28.5 0.89-0.7 2-0.5 25.47-4.89 35.5 19 0.75 4.98 0.5 10z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s36" d="m72.5 335.5q3.62-0.38 5 3-4.22 1.83-5-3z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s37" d="m223.5 336.5q5.59-0.48 11 1-4.04 4.16-8.5 8-5.99-3.8-2.5-9z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s38" d="m90.5 334.5q0.59-1.54 2-0.5 3.94 5.45 9 10 7 6 14 12-6.91-1.7-13-6-6.21-7.72-12-15.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s39" d="m261.5 346.5q-3.54-2.44-8-3.5-6.98-0.75-14-0.5 0.63-1.08 2-1.5 13.82-2.52 26 4-2.63 1.98-6 1.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s40" d="m239.5 342.5q7.02-0.25 14 0.5 4.46 1.06 8 3.5-5.2 2.35-10 5.5-3.88 4.65-9 7.5-9.89-3.09-9.5-13 2.36-3.63 6.5-4z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s41" d="m214.5 349.5q-21.43 15.48-48 16 22.82-5.9 43-18.5 3.64-1.12 5 2.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s42" d="m214.5 349.5q5.96 7.2 13.5 13 1 1 0 2-28.58 23.34-65.5 20.5-18.15-4.24-27.5-19.5 1.13 0.94 2.5 1.5 14.7 1.42 29-1.5 26.57-0.52 48-16z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s43" d="m302.5 373.5q-14.74-16.73-37-19-4.55 0.25-9 1 25.3-10.24 43.5 11 2.85 2.91 2.5 7z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s44" d="m302.5 373.5q0.21 2.44-2 3.5-28.69 7.6-50.5-12.5-0.06-6.71 6.5-9 4.45-0.75 9-1 22.26 2.27 37 19z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s45" d="m100.5 356.5q5.42 2.71 11 5.5-13.04 7.54-18.5 21.5-7.57-7.14-10.5-17 5.58 1.54 10 5.5 4.2 0.84 5.5-3.5 1.41-5.99 2.5-12z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s8" d="m83.5 394.5q-18.9-10.15-29.5-29-1.54-3.52-2-7 5.79 2.39 10 7 7.82 16.63 21.5 29z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s46" d="m232.5 365.5q17.6 6.19 10.5 23-10.6 10.42-25.5 11.5-25.94 3.21-49-9 36.75-1.65 64-25.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s47" d="m113.5 367.5q7.7-0.01 9.5 7-9.69 7.19-18.5 15.5-7.23 5.76-5.5-3.5 3.12-12.84 14.5-19z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s29" d="m126.5 380.5q7.88-0.4 12 6.5-8.5 7.25-17 14.5-5.62-12.55 5-21z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s48" d="m283.5 385.5q3.22 2.95 7 5.5 2.8 4.03 6 7.5 0.42 2.77-2 4-15.5-9.75-31-19.5-1.79-0.98 0-1.5 9.96 2.49 20 4z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s49" d="m283.5 385.5q8.71-1.27 11.5 7 1.22 2.9 1.5 6-3.2-3.47-6-7.5-3.78-2.55-7-5.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s50" d="m83.5 394.5q1.88-0.06 3 1.5-2.25 0.88-3-1.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s51" d="m258.5 392.5q3.51 0.41 0 2.5-2.33 1.93-5 2 2.61-2.28 5-4.5z"/>
+	</g>
+	<g>
+		<path fill-rule="evenodd" class="s52" d="m111.5 392.5q0.09-0.81 1-1 1.48 4.9 1 10-1-4.5-2-9z"/>
+	</g>
+</svg>

app/ui/app/public/launch-icons/opencode.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512"><svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="512" height="512" fill="#131010"></rect>
+<path d="M320 224V352H192V224H320Z" fill="#5A5858"></path>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="white"></path>
+</svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
+@media (prefers-color-scheme: dark) { :root { filter: none; } }
+</style></svg>

app/ui/app/public/launch-icons/pi-dark.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
+  <rect width="800" height="800" rx="160" fill="#fff"/>
+  <path fill="#000" fill-rule="evenodd" d="
+    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
+    M282.65 282.65 V400 H400 V282.65 Z
+  "/>
+  <path fill="#000" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
+</svg>

app/ui/app/public/launch-icons/pi.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
+  <rect width="800" height="800" rx="160" fill="#000"/>
+  <path fill="#fff" fill-rule="evenodd" d="
+    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
+    M282.65 282.65 V400 H400 V282.65 Z
+  "/>
+  <path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
+</svg>

app/ui/app/src/api.ts

@@ -0,0 +1,480 @@
+import {
+  ChatResponse,
+  ChatsResponse,
+  ChatEvent,
+  DownloadEvent,
+  ErrorEvent,
+  InferenceComputeResponse,
+  ModelCapabilitiesResponse,
+  Model,
+  ChatRequest,
+  Settings,
+  User,
+} from "@/gotypes";
+import { parseJsonlFromResponse } from "./util/jsonl-parsing";
+import { ollamaClient as ollama } from "./lib/ollama-client";
+import type { ModelResponse } from "ollama/browser";
+import { API_BASE, OLLAMA_DOT_COM } from "./lib/config";
+
+// Extend Model class with utility methods
+declare module "@/gotypes" {
+  interface Model {
+    isCloud(): boolean;
+  }
+}
+
+Model.prototype.isCloud = function (): boolean {
+  return this.model.endsWith("cloud");
+};
+
+export type CloudStatusSource = "env" | "config" | "both" | "none";
+export interface CloudStatusResponse {
+  disabled: boolean;
+  source: CloudStatusSource;
+}
+// Helper function to convert Uint8Array to base64
+function uint8ArrayToBase64(uint8Array: Uint8Array): string {
+  const chunkSize = 0x8000; // 32KB chunks to avoid stack overflow
+  let binary = "";
+
+  for (let i = 0; i < uint8Array.length; i += chunkSize) {
+    const chunk = uint8Array.subarray(i, i + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+
+  return btoa(binary);
+}
+
+export async function fetchUser(): Promise<User | null> {
+  const response = await fetch(`${API_BASE}/api/me`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (response.ok) {
+    const userData: User = await response.json();
+
+    if (userData.avatarurl && !userData.avatarurl.startsWith("http")) {
+      userData.avatarurl = `${OLLAMA_DOT_COM}${userData.avatarurl}`;
+    }
+
+    return userData;
+  }
+
+  if (response.status === 401 || response.status === 403) {
+    return null;
+  }
+
+  throw new Error(`Failed to fetch user: ${response.status}`);
+}
+
+export async function fetchConnectUrl(): Promise<string> {
+  const response = await fetch(`${API_BASE}/api/me`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (response.status === 401) {
+    const data = await response.json();
+    if (data.signin_url) {
+      return data.signin_url;
+    }
+  }
+
+  throw new Error("Failed to fetch connect URL");
+}
+
+export async function disconnectUser(): Promise<void> {
+  const response = await fetch(`${API_BASE}/api/signout`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error("Failed to disconnect user");
+  }
+}
+
+export async function getChats(): Promise<ChatsResponse> {
+  const response = await fetch(`${API_BASE}/api/v1/chats`);
+  const data = await response.json();
+  return new ChatsResponse(data);
+}
+
+export async function getChat(chatId: string): Promise<ChatResponse> {
+  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}`);
+  const data = await response.json();
+  return new ChatResponse(data);
+}
+
+export async function getModels(query?: string): Promise<Model[]> {
+  try {
+    const { models: modelsResponse } = await ollama.list();
+
+    let models: Model[] = modelsResponse
+      .filter((m: ModelResponse) => {
+        const families = m.details?.families;
+
+        if (!families || families.length === 0) {
+          return true;
+        }
+
+        const isBertOnly = families.every((family: string) =>
+          family.toLowerCase().includes("bert"),
+        );
+
+        return !isBertOnly;
+      })
+      .map((m: ModelResponse) => {
+        // Remove the latest tag from the returned model
+        const modelName = m.name.replace(/:latest$/, "");
+
+        return new Model({
+          model: modelName,
+          digest: m.digest,
+          modified_at: m.modified_at ? new Date(m.modified_at) : undefined,
+        });
+      });
+
+    // Filter by query if provided
+    if (query) {
+      const normalizedQuery = query.toLowerCase().trim();
+
+      const filteredModels = models.filter((m: Model) => {
+        return m.model.toLowerCase().startsWith(normalizedQuery);
+      });
+
+      let exactMatch = false;
+      for (const m of filteredModels) {
+        if (m.model.toLowerCase() === normalizedQuery) {
+          exactMatch = true;
+          break;
+        }
+      }
+
+      // Add query if it's in the registry and not already in the list
+      if (!exactMatch) {
+        const result = await getModelUpstreamInfo(new Model({ model: query }));
+        const existsUpstream = result.exists;
+        if (existsUpstream) {
+          filteredModels.push(new Model({ model: query }));
+        }
+      }
+
+      models = filteredModels;
+    }
+
+    return models;
+  } catch (err) {
+    throw new Error(`Failed to fetch models: ${err}`);
+  }
+}
+
+export async function getModelCapabilities(
+  modelName: string,
+): Promise<ModelCapabilitiesResponse> {
+  try {
+    const showResponse = await ollama.show({ model: modelName });
+
+    return new ModelCapabilitiesResponse({
+      capabilities: Array.isArray(showResponse.capabilities)
+        ? showResponse.capabilities
+        : [],
+    });
+  } catch (error) {
+    // Model might not be downloaded yet, return empty capabilities
+    console.error(`Failed to get capabilities for ${modelName}:`, error);
+    return new ModelCapabilitiesResponse({ capabilities: [] });
+  }
+}
+
+export type ChatEventUnion = ChatEvent | DownloadEvent | ErrorEvent;
+
+export async function* sendMessage(
+  chatId: string,
+  message: string,
+  model: Model,
+  attachments?: Array<{ filename: string; data: Uint8Array }>,
+  signal?: AbortSignal,
+  index?: number,
+  webSearch?: boolean,
+  fileTools?: boolean,
+  forceUpdate?: boolean,
+  think?: boolean | string,
+): AsyncGenerator<ChatEventUnion> {
+  // Convert Uint8Array to base64 for JSON serialization
+  const serializedAttachments = attachments?.map((att) => ({
+    filename: att.filename,
+    data: uint8ArrayToBase64(att.data),
+  }));
+
+  // Send think parameter when it's explicitly set (true, false, or a non-empty string).
+  const shouldSendThink =
+    think !== undefined &&
+    (typeof think === "boolean" || (typeof think === "string" && think !== ""));
+
+  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(
+      new ChatRequest({
+        model: model.model,
+        prompt: message,
+        ...(index !== undefined ? { index } : {}),
+        ...(serializedAttachments !== undefined
+          ? { attachments: serializedAttachments }
+          : {}),
+        // Always send web_search as a boolean value (default to false)
+        web_search: webSearch ?? false,
+        file_tools: fileTools ?? false,
+        ...(forceUpdate !== undefined ? { forceUpdate } : {}),
+        ...(shouldSendThink ? { think } : {}),
+      }),
+    ),
+    signal,
+  });
+
+  for await (const event of parseJsonlFromResponse<ChatEventUnion>(response)) {
+    switch (event.eventName) {
+      case "download":
+        yield new DownloadEvent(event);
+        break;
+      case "error":
+        yield new ErrorEvent(event);
+        break;
+      default:
+        yield new ChatEvent(event);
+        break;
+    }
+  }
+}
+
+export async function getSettings(): Promise<{
+  settings: Settings;
+}> {
+  const response = await fetch(`${API_BASE}/api/v1/settings`);
+  if (!response.ok) {
+    throw new Error("Failed to fetch settings");
+  }
+  const data = await response.json();
+  return {
+    settings: new Settings(data.settings),
+  };
+}
+
+export async function updateSettings(settings: Settings): Promise<{
+  settings: Settings;
+}> {
+  const response = await fetch(`${API_BASE}/api/v1/settings`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(settings),
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(error || "Failed to update settings");
+  }
+  const data = await response.json();
+  return {
+    settings: new Settings(data.settings),
+  };
+}
+
+export async function updateCloudSetting(
+  enabled: boolean,
+): Promise<CloudStatusResponse> {
+  const response = await fetch(`${API_BASE}/api/v1/cloud`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ enabled }),
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(error || "Failed to update cloud setting");
+  }
+
+  const data = await response.json();
+  return {
+    disabled: Boolean(data.disabled),
+    source: (data.source as CloudStatusSource) || "none",
+  };
+}
+
+export async function renameChat(chatId: string, title: string): Promise<void> {
+  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}/rename`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ title: title.trim() }),
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(error || "Failed to rename chat");
+  }
+}
+
+export async function deleteChat(chatId: string): Promise<void> {
+  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}`, {
+    method: "DELETE",
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(error || "Failed to delete chat");
+  }
+}
+
+// Get upstream information for model staleness checking
+export async function getModelUpstreamInfo(
+  model: Model,
+): Promise<{ stale: boolean; exists: boolean; error?: string }> {
+  try {
+    const response = await fetch(`${API_BASE}/api/v1/model/upstream`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: model.model,
+      }),
+    });
+
+    if (!response.ok) {
+      console.warn(
+        `Failed to check upstream for ${model.model}: ${response.status}`,
+      );
+      return { stale: false, exists: false };
+    }
+
+    const data = await response.json();
+
+    if (data.error) {
+      console.warn(`Upstream check: ${data.error}`);
+      return { stale: false, exists: false, error: data.error };
+    }
+
+    return { stale: !!data.stale, exists: true };
+  } catch (error) {
+    console.warn(`Error checking model staleness:`, error);
+    return { stale: false, exists: false };
+  }
+}
+
+export async function* pullModel(
+  modelName: string,
+  signal?: AbortSignal,
+): AsyncGenerator<{
+  status: string;
+  digest?: string;
+  total?: number;
+  completed?: number;
+  done?: boolean;
+}> {
+  const response = await fetch(`${API_BASE}/api/v1/models/pull`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ name: modelName }),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to pull model: ${response.statusText}`);
+  }
+
+  for await (const event of parseJsonlFromResponse<{
+    status: string;
+    digest?: string;
+    total?: number;
+    completed?: number;
+    done?: boolean;
+  }>(response)) {
+    yield event;
+  }
+}
+
+export interface ModelRecommendation {
+  model: string;
+  description: string;
+  context_length?: number;
+  max_output_tokens?: number;
+  vram_bytes?: number;
+}
+
+export interface ModelRecommendationsResponse {
+  recommendations: ModelRecommendation[];
+}
+
+export async function getModelRecommendations(): Promise<ModelRecommendation[]> {
+  const response = await fetch(
+    `${API_BASE}/api/experimental/model-recommendations`,
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch model recommendations: ${response.statusText}`,
+    );
+  }
+  const data: ModelRecommendationsResponse = await response.json();
+  return data.recommendations || [];
+}
+
+export async function getInferenceCompute(): Promise<InferenceComputeResponse> {
+  const response = await fetch(`${API_BASE}/api/v1/inference-compute`);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch inference compute: ${response.statusText}`,
+    );
+  }
+
+  const data = await response.json();
+  return new InferenceComputeResponse(data);
+}
+
+export async function fetchHealth(): Promise<boolean> {
+  try {
+    // Use the /api/version endpoint as a health check
+    const response = await fetch(`${API_BASE}/api/version`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      // If we get a version back, the server is healthy
+      return !!data.version;
+    }
+
+    return false;
+  } catch (error) {
+    console.error("Error checking health:", error);
+    return false;
+  }
+}
+
+export async function getCloudStatus(): Promise<CloudStatusResponse | null> {
+  const response = await fetch(`${API_BASE}/api/v1/cloud`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch cloud status: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return {
+    disabled: Boolean(data.disabled),
+    source: (data.source as CloudStatusSource) || "none",
+  };
+}

app/ui/app/src/components/Chat.tsx

@@ -0,0 +1,298 @@
+import MessageList from "./MessageList";
+import ChatForm from "./ChatForm";
+import { FileUpload } from "./FileUpload";
+import { DisplayUpgrade } from "./DisplayUpgrade";
+import { DisplayStale } from "./DisplayStale";
+import { DisplayLogin } from "./DisplayLogin";
+import {
+  useChat,
+  useSendMessage,
+  useIsStreaming,
+  useIsWaitingForLoad,
+  useDownloadProgress,
+  useChatError,
+  useShouldShowStaleDisplay,
+  useDismissStaleModel,
+} from "@/hooks/useChats";
+import { useHealth } from "@/hooks/useHealth";
+import { useMessageAutoscroll } from "@/hooks/useMessageAutoscroll";
+import {
+  useState,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useCallback,
+} from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useNavigate } from "@tanstack/react-router";
+import { useSelectedModel } from "@/hooks/useSelectedModel";
+import { useUser } from "@/hooks/useUser";
+import { useHasVisionCapability } from "@/hooks/useModelCapabilities";
+import { Message } from "@/gotypes";
+
+export default function Chat({ chatId }: { chatId: string }) {
+  const queryClient = useQueryClient();
+  const navigate = useNavigate();
+  const chatQuery = useChat(chatId === "new" ? "" : chatId);
+  const chatErrorQuery = useChatError(chatId === "new" ? "" : chatId);
+  const { selectedModel } = useSelectedModel(chatId);
+  const { user } = useUser();
+  const hasVisionCapability = useHasVisionCapability(selectedModel?.model);
+  const shouldShowStaleDisplay = useShouldShowStaleDisplay(selectedModel);
+  const dismissStaleModel = useDismissStaleModel();
+  const { isHealthy } = useHealth();
+
+  const [editingMessage, setEditingMessage] = useState<{
+    content: string;
+    index: number;
+    originalMessage: Message;
+  } | null>(null);
+  const prevChatIdRef = useRef<string>(chatId);
+
+  const chatFormCallbackRef = useRef<
+    | ((
+        files: Array<{ filename: string; data: Uint8Array; type?: string }>,
+        errors: Array<{ filename: string; error: string }>,
+      ) => void)
+    | null
+  >(null);
+
+  const handleFilesReceived = useCallback(
+    (
+      callback: (
+        files: Array<{
+          filename: string;
+          data: Uint8Array;
+          type?: string;
+        }>,
+        errors: Array<{ filename: string; error: string }>,
+      ) => void,
+    ) => {
+      chatFormCallbackRef.current = callback;
+    },
+    [],
+  );
+
+  const handleFilesProcessed = useCallback(
+    (
+      files: Array<{ filename: string; data: Uint8Array; type?: string }>,
+      errors: Array<{ filename: string; error: string }> = [],
+    ) => {
+      chatFormCallbackRef.current?.(files, errors);
+    },
+    [],
+  );
+
+  const allMessages = chatQuery?.data?.chat?.messages ?? [];
+  // TODO(parthsareen): will need to consolidate when used with more tools with state
+  const browserToolResult = chatQuery?.data?.chat?.browser_state;
+  const chatError = chatErrorQuery.data;
+
+  const messages = allMessages;
+  const isStreaming = useIsStreaming(chatId);
+  const isWaitingForLoad = useIsWaitingForLoad(chatId);
+  const downloadProgress = useDownloadProgress(chatId);
+  const isDownloadingModel = downloadProgress && !downloadProgress.done;
+  const isDisabled = !isHealthy;
+
+  // Clear editing state when navigating to a different chat
+  useEffect(() => {
+    setEditingMessage(null);
+  }, [chatId]);
+
+  const sendMessageMutation = useSendMessage(chatId);
+
+  const { containerRef, handleNewUserMessage, spacerHeight } =
+    useMessageAutoscroll({
+      messages,
+      isStreaming,
+      chatId,
+    });
+
+  // Scroll to bottom only when switching to a different existing chat
+  useLayoutEffect(() => {
+    // Only scroll if the chatId actually changed (not just messages updating)
+    if (
+      prevChatIdRef.current !== chatId &&
+      containerRef.current &&
+      messages.length > 0 &&
+      chatId !== "new"
+    ) {
+      // Always scroll to the bottom when opening a chat
+      containerRef.current.scrollTop = containerRef.current.scrollHeight;
+    }
+    prevChatIdRef.current = chatId;
+  }, [chatId, messages.length]);
+
+  // Simplified submit handler - ChatForm handles all the attachment logic
+  const handleChatFormSubmit = (
+    message: string,
+    options: {
+      attachments?: Array<{ filename: string; data: Uint8Array }>;
+      index?: number;
+      webSearch?: boolean;
+      fileTools?: boolean;
+      think?: boolean | string;
+    },
+  ) => {
+    // Clear any existing errors when sending a new message
+    sendMessageMutation.reset();
+    if (chatError) {
+      clearChatError();
+    }
+
+    // Prepare attachments for backend
+    const allAttachments = (options.attachments || []).map((att) => ({
+      filename: att.filename,
+      data: att.data.length === 0 ? new Uint8Array(0) : att.data,
+    }));
+
+    sendMessageMutation.mutate({
+      message,
+      attachments: allAttachments,
+      index: editingMessage ? editingMessage.index : options.index,
+      webSearch: options.webSearch,
+      fileTools: options.fileTools,
+      think: options.think,
+      onChatEvent: (event) => {
+        if (event.eventName === "chat_created" && event.chatId) {
+          navigate({
+            to: "/c/$chatId",
+            params: {
+              chatId: event.chatId,
+            },
+          });
+        }
+      },
+    });
+
+    // Clear edit mode after submission
+    setEditingMessage(null);
+    handleNewUserMessage();
+  };
+
+  const handleEditMessage = (content: string, index: number) => {
+    setEditingMessage({
+      content,
+      index,
+      originalMessage: messages[index],
+    });
+  };
+
+  const handleCancelEdit = () => {
+    setEditingMessage(null);
+    if (chatError) {
+      clearChatError();
+    }
+  };
+
+  const clearChatError = () => {
+    queryClient.setQueryData(
+      ["chatError", chatId === "new" ? "" : chatId],
+      null,
+    );
+  };
+
+  const isWindows = navigator.platform.toLowerCase().includes("win");
+
+  return chatId === "new" || chatQuery ? (
+    <FileUpload
+      onFilesAdded={handleFilesProcessed}
+      selectedModel={selectedModel}
+      hasVisionCapability={hasVisionCapability}
+    >
+      {chatId === "new" ? (
+        <div className="flex flex-col h-screen justify-center relative">
+          <div className="px-6">
+            <ChatForm
+              hasMessages={false}
+              onSubmit={handleChatFormSubmit}
+              chatId={chatId}
+              autoFocus={true}
+              editingMessage={editingMessage}
+              onCancelEdit={handleCancelEdit}
+              isDownloadingModel={isDownloadingModel}
+              isDisabled={isDisabled}
+              onFilesReceived={handleFilesReceived}
+            />
+          </div>
+        </div>
+      ) : (
+        <main className="flex h-screen w-full flex-col relative allow-context-menu select-none">
+          <section
+            key={chatId} // This key forces React to recreate the element when chatId changes
+            ref={containerRef}
+            className={`flex-1 overflow-y-auto overscroll-contain relative min-h-0 select-none ${isWindows ? "xl:pt-4" : "xl:pt-8"}`}
+          >
+            <MessageList
+              messages={messages}
+              spacerHeight={spacerHeight}
+              isWaitingForLoad={isWaitingForLoad}
+              isStreaming={isStreaming}
+              downloadProgress={downloadProgress}
+              onEditMessage={(content: string, index: number) => {
+                handleEditMessage(content, index);
+              }}
+              editingMessageIndex={editingMessage?.index}
+              error={chatError}
+              browserToolResult={browserToolResult}
+            />
+          </section>
+
+          <div className="flex-shrink-0 sticky bottom-0 z-20">
+            {selectedModel && shouldShowStaleDisplay && (
+              <div className="pb-2">
+                <DisplayStale
+                  model={selectedModel}
+                  onDismiss={() =>
+                    dismissStaleModel(selectedModel?.model || "")
+                  }
+                  chatId={chatId}
+                  onScrollToBottom={() => {
+                    if (containerRef.current) {
+                      containerRef.current.scrollTo({
+                        top: containerRef.current.scrollHeight,
+                        behavior: "smooth",
+                      });
+                    }
+                  }}
+                />
+              </div>
+            )}
+            {chatError && chatError.code === "usage_limit_upgrade" && (
+              <div className="pb-2">
+                <DisplayUpgrade
+                  error={chatError}
+                  onDismiss={clearChatError}
+                  href={
+                    user?.plan === "pro"
+                      ? "https://ollama.com/settings/billing"
+                      : "https://ollama.com/upgrade"
+                  }
+                />
+              </div>
+            )}
+            {chatError && chatError.code === "cloud_unauthorized" && (
+              <div className="pb-2">
+                <DisplayLogin error={chatError} />
+              </div>
+            )}
+            <ChatForm
+              hasMessages={messages.length > 0}
+              onSubmit={handleChatFormSubmit}
+              chatId={chatId}
+              autoFocus={true}
+              editingMessage={editingMessage}
+              onCancelEdit={handleCancelEdit}
+              isDisabled={isDisabled}
+              isDownloadingModel={isDownloadingModel}
+              onFilesReceived={handleFilesReceived}
+            />
+          </div>
+        </main>
+      )}
+    </FileUpload>
+  ) : (
+    <div>Loading...</div>
+  );
+}

app/ui/app/src/components/ChatSidebar.tsx

@@ -0,0 +1,396 @@
+import { useChats } from "@/hooks/useChats";
+import { useRenameChat } from "@/hooks/useRenameChat";
+import { useDeleteChat } from "@/hooks/useDeleteChat";
+import { useQueryClient } from "@tanstack/react-query";
+import { getChat } from "@/api";
+import { Link } from "@/components/ui/link";
+import { useState, useRef, useEffect, useCallback, useMemo } from "react";
+import { ChatsResponse } from "@/gotypes";
+import { CogIcon, RocketLaunchIcon } from "@heroicons/react/24/outline";
+
+// there's a hidden debug feature to copy a chat's data to the clipboard by
+// holding shift and clicking this many times within this many seconds
+const DEBUG_SHIFT_CLICKS_REQUIRED = 5;
+const DEBUG_SHIFT_CLICK_WINDOW_MS = 7000; // 7 seconds
+const launchSidebarRequestedKey = "ollama.launchSidebarRequested";
+
+interface ChatSidebarProps {
+  currentChatId?: string;
+}
+
+export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
+  const { data, isLoading, error } = useChats();
+  const queryClient = useQueryClient();
+  const renameMutation = useRenameChat();
+  const deleteMutation = useDeleteChat();
+  const [editingChatId, setEditingChatId] = useState<string | null>(null);
+  const [editValue, setEditValue] = useState("");
+  const inputRef = useRef<HTMLInputElement>(null);
+  const [shiftClicks, setShiftClicks] = useState<Record<string, number[]>>({});
+  const [copiedChatId, setCopiedChatId] = useState<string | null>(null);
+
+  const handleMouseEnter = useCallback(
+    (chatId: string) => {
+      queryClient.prefetchQuery({
+        queryKey: ["chat", chatId],
+        queryFn: () => getChat(chatId),
+        staleTime: 1500,
+      });
+    },
+    [queryClient],
+  );
+
+  const startEditing = useCallback((chatId: string, currentTitle: string) => {
+    setEditingChatId(chatId);
+    setEditValue(currentTitle);
+  }, []);
+
+  const saveRename = useCallback(async () => {
+    if (!editingChatId || !editValue.trim()) {
+      setEditingChatId(null);
+      return;
+    }
+
+    const newTitle = editValue.trim();
+    const chatId = editingChatId;
+
+    // Exit edit mode immediately to prevent flash
+    setEditingChatId(null);
+    setEditValue("");
+
+    // Optimistically update the cache
+    queryClient.setQueryData(
+      ["chats"],
+      (oldData: ChatsResponse | undefined) => {
+        if (!oldData?.chatInfos) return oldData;
+        return {
+          ...oldData,
+          chatInfos: oldData.chatInfos.map((chat) =>
+            chat.id === chatId ? { ...chat, title: newTitle } : chat,
+          ),
+        };
+      },
+    );
+
+    try {
+      await renameMutation.mutateAsync({
+        chatId: chatId,
+        title: newTitle,
+      });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error: unknown) {
+      // Revert optimistic update on error
+      queryClient.invalidateQueries({ queryKey: ["chats"] });
+    }
+  }, [editingChatId, editValue, renameMutation, queryClient]);
+
+  useEffect(() => {
+    if (editingChatId && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [editingChatId]);
+
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (
+        inputRef.current &&
+        !inputRef.current.contains(event.target as Node)
+      ) {
+        saveRename();
+      }
+    };
+
+    if (editingChatId) {
+      document.addEventListener("mousedown", handleClickOutside);
+      return () => {
+        document.removeEventListener("mousedown", handleClickOutside);
+      };
+    }
+  }, [editingChatId, editValue, saveRename]);
+
+  const sortedChats = useMemo(() => {
+    if (!data?.chatInfos) return [];
+    return [...data.chatInfos].sort((a, b) => {
+      const comparison = b.updatedAt.getTime() - a.updatedAt.getTime();
+      if (comparison === 0) {
+        return b.id.localeCompare(a.id);
+      }
+      return comparison;
+    });
+  }, [data?.chatInfos]);
+
+  const isToday = (date: Date) => {
+    const today = new Date();
+    return (
+      date.getDate() === today.getDate() &&
+      date.getMonth() === today.getMonth() &&
+      date.getFullYear() === today.getFullYear()
+    );
+  };
+
+  const isThisWeek = (date: Date) => {
+    const now = new Date();
+    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    return date > weekAgo && !isToday(date);
+  };
+
+  // Group chats by time period
+  const groupedChats = useMemo(() => {
+    const groups = {
+      today: [] as typeof sortedChats,
+      thisWeek: [] as typeof sortedChats,
+      older: [] as typeof sortedChats,
+    };
+
+    sortedChats.forEach((chat) => {
+      if (isToday(chat.updatedAt)) {
+        groups.today.push(chat);
+      } else if (isThisWeek(chat.updatedAt)) {
+        groups.thisWeek.push(chat);
+      } else {
+        groups.older.push(chat);
+      }
+    });
+
+    return groups;
+  }, [sortedChats]);
+
+  const chatGroups = useMemo(() => {
+    return [
+      { name: "Today", chats: groupedChats.today },
+      { name: "This week", chats: groupedChats.thisWeek },
+      { name: "Older", chats: groupedChats.older },
+    ].filter((group) => group.chats.length > 0);
+  }, [groupedChats]);
+
+  const handleDeleteChat = useCallback(
+    async (chatId: string) => {
+      const confirmed = window.confirm(
+        `Are you sure you want to remove this chat?`,
+      );
+
+      if (!confirmed) return;
+
+      try {
+        await deleteMutation.mutateAsync(chatId);
+      } catch (error) {
+        console.error("Failed to delete chat:", error);
+      }
+    },
+    [deleteMutation],
+  );
+
+  // implementation of the hidden debug feature to copy a chat's data to the clipboard
+  const handleShiftClick = useCallback(
+    async (e: React.MouseEvent, chatId: string) => {
+      if (!e.shiftKey) return false;
+
+      e.preventDefault();
+      const now = Date.now();
+
+      const clicks = shiftClicks[chatId] || [];
+      const recentClicks = clicks.filter(
+        (timestamp) => now - timestamp < DEBUG_SHIFT_CLICK_WINDOW_MS,
+      );
+      recentClicks.push(now);
+
+      setShiftClicks((prev) => ({
+        ...prev,
+        [chatId]: recentClicks,
+      }));
+
+      if (recentClicks.length >= DEBUG_SHIFT_CLICKS_REQUIRED) {
+        try {
+          const chatData = await getChat(chatId);
+          const jsonString = JSON.stringify(chatData, null, 2);
+          await navigator.clipboard.writeText(jsonString);
+
+          // visual feedback
+          setCopiedChatId(chatId);
+          setTimeout(() => setCopiedChatId(null), 2000);
+
+          setShiftClicks((prev) => ({
+            ...prev,
+            [chatId]: [],
+          }));
+        } catch (error) {
+          console.error("Failed to copy chat data:", error);
+        }
+      }
+
+      return true;
+    },
+    [shiftClicks],
+  );
+
+  const handleContextMenu = useCallback(
+    async (_: React.MouseEvent, chatId: string, chatTitle: string) => {
+      const selectedAction = await window.menu([
+        { label: "Rename", enabled: true },
+        { label: "Delete", enabled: true },
+      ]);
+
+      if (selectedAction === "Rename") {
+        startEditing(chatId, chatTitle);
+      } else if (selectedAction === "Delete") {
+        handleDeleteChat(chatId);
+      }
+    },
+    [startEditing, handleDeleteChat],
+  );
+
+  if (isLoading) {
+    return (
+      <nav className="flex min-h-0 flex-col">
+        <div className="flex flex-1 flex-col p-4">
+          <div className="p-4">Loading...</div>
+        </div>
+      </nav>
+    );
+  }
+
+  if (error) {
+    return (
+      <nav className="flex min-h-0 flex-col">
+        <div className="flex flex-1 flex-col p-4">
+          <div className="p-4 text-red-500">Error loading chats</div>
+        </div>
+      </nav>
+    );
+  }
+
+  const isWindows = navigator.platform.toLowerCase().includes("win");
+
+  return (
+    <nav className="flex flex-1 flex-col min-h-0 select-none">
+      <header className="flex flex-col gap-0.5 px-4 pb-2">
+        <Link
+          href="/c/new"
+          mask={{ to: "/" }}
+          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 ${currentChatId === "new" ? "bg-neutral-100 dark:bg-neutral-800" : ""
+            }`}
+          draggable={false}
+        >
+          <svg
+            className="h-5 w-5 fill-current"
+            viewBox="0 0 24 24"
+            fill="none"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <path d="M17.0859 3.39949L15.2135 5.27196H7.27028C5.78649 5.27196 4.94684 6.11336 4.94684 7.59716V16.664C4.94684 18.1558 5.78649 18.9892 7.27028 18.9892H16.3406C17.8324 18.9892 18.6623 18.1558 18.6623 16.664V8.79514L20.5428 6.9115C20.567 7.11532 20.5773 7.33066 20.5773 7.55419V16.7149C20.5773 19.4069 19.0818 20.9024 16.3898 20.9024H7.22107C4.53708 20.9024 3.03357 19.4069 3.03357 16.7149V7.55419C3.03357 4.8622 4.53708 3.35869 7.22107 3.35869H16.3898C16.6329 3.35869 16.8662 3.37094 17.0859 3.39949Z" />
+            <path d="M9.92714 14.381L11.914 13.5403L20.8312 4.63114L19.3404 3.1581L10.433 12.0655L9.55234 13.9964C9.45664 14.2169 9.70293 14.4714 9.92714 14.381ZM21.5767 3.89364L22.2588 3.19384C22.6347 2.80184 22.6435 2.2663 22.2711 1.90536L22.0148 1.64287C21.6822 1.31377 21.1334 1.36513 20.7689 1.72158L20.0859 2.39833L21.5767 3.89364Z" />
+          </svg>
+          <span className="truncate">New Chat</span>
+        </Link>
+        <Link
+          to="/c/$chatId"
+          params={{ chatId: "launch" }}
+          onClick={() => {
+            if (currentChatId !== "launch") {
+              sessionStorage.setItem(launchSidebarRequestedKey, "1");
+            }
+          }}
+          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 cursor-pointer ${currentChatId === "launch"
+            ? "bg-neutral-100 dark:bg-neutral-800"
+            : ""
+            }`}
+          draggable={false}
+        >
+          <RocketLaunchIcon className="h-5 w-5 stroke-current" />
+          <span className="truncate">Launch</span>
+        </Link>
+        {isWindows && (
+          <Link
+            href="/settings"
+            className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-300`}
+            draggable={false}
+          >
+            <CogIcon className="h-5 w-5 stroke-current" />
+            <span className="truncate">Settings</span>
+          </Link>
+        )}
+      </header>
+      <div className="flex flex-1 flex-col px-4 py-1 overflow-y-auto overscroll-auto scrollbar-gutter">
+        <div className="flex flex-col gap-3 pt-4">
+          {chatGroups.map((group) => (
+            <div key={group.name} className="flex flex-col gap-0.5">
+              <h3 className="text-xs font-medium text-neutral-400 dark:text-neutral-500 px-2 py-1 select-none">
+                {group.name}
+              </h3>
+              {group.chats.map((chat) => (
+                <div
+                  key={chat.id}
+                  className={`allow-context-menu flex items-center relative text-sm text-neutral-800 dark:text-neutral-400 rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 ${chat.id === currentChatId
+                    ? "bg-neutral-100 text-black dark:bg-neutral-800"
+                    : ""
+                    }`}
+                  onMouseEnter={() => handleMouseEnter(chat.id)}
+                  onContextMenu={(e) =>
+                    handleContextMenu(
+                      e,
+                      chat.id,
+                      chat.title ||
+                      chat.userExcerpt ||
+                      chat.createdAt.toLocaleString(),
+                    )
+                  }
+                >
+                  {editingChatId === chat.id ? (
+                    <div className="flex-1 flex items-center min-w-0 px-2 py-2 bg-neutral-100 text-black dark:bg-neutral-800 rounded-lg">
+                      <span className="truncate font-sans text-sm w-full">
+                        <input
+                          ref={inputRef}
+                          type="text"
+                          value={editValue}
+                          onChange={(e) => setEditValue(e.target.value)}
+                          onKeyDown={(e) => {
+                            if (e.key === "Enter") {
+                              e.preventDefault();
+                              saveRename();
+                            } else if (e.key === "Escape") {
+                              setEditingChatId(null);
+                              setEditValue("");
+                            }
+                          }}
+                          className="bg-transparent border-0 focus:outline-none w-full dark:text-white"
+                          style={{
+                            font: "inherit",
+                            lineHeight: "inherit",
+                            padding: 0,
+                            margin: 0,
+                          }}
+                        />
+                      </span>
+                    </div>
+                  ) : (
+                    <Link
+                      to="/c/$chatId"
+                      params={{ chatId: chat.id }}
+                      className="flex-1 flex items-center min-w-0 px-2 py-2 select-none"
+                      onClick={(e) => {
+                        handleShiftClick(e, chat.id);
+                      }}
+                      draggable={false}
+                    >
+                      <span className="truncate font-sans text-sm">
+                        {chat.title ||
+                          chat.userExcerpt ||
+                          chat.createdAt.toLocaleString()}
+                      </span>
+                      {copiedChatId === chat.id && (
+                        <span className="ml-2 text-xs text-green-600 dark:text-green-400">
+                          Copied!
+                        </span>
+                      )}
+                    </Link>
+                  )}
+                </div>
+              ))}
+            </div>
+          ))}
+        </div>
+      </div>
+    </nav>
+  );
+}

app/ui/app/src/components/CopyButton.tsx

@@ -0,0 +1,99 @@
+import { CheckIcon } from "@heroicons/react/20/solid";
+import { Square2StackIcon } from "@heroicons/react/24/outline";
+import React, { useState } from "react";
+
+interface CopyButtonProps {
+  content: string;
+  copyRef?: React.RefObject<HTMLElement | null>;
+  removeClasses?: string[];
+  size?: "sm" | "md";
+  showLabels?: boolean;
+  className?: string;
+  title?: string;
+  onCopy?: () => void;
+}
+
+const CopyButton: React.FC<CopyButtonProps> = ({
+  content,
+  copyRef,
+  removeClasses = [],
+  size = "sm",
+  showLabels = false,
+  className = "",
+  title = "",
+  onCopy,
+}) => {
+  const [isCopied, setIsCopied] = useState(false);
+
+  const handleCopy = async () => {
+    try {
+      if (copyRef?.current) {
+        // For copy response message
+        const cloned = copyRef.current.cloneNode(true) as HTMLElement;
+
+        removeClasses.forEach((className) => {
+          cloned
+            .querySelectorAll(`.${className}`)
+            .forEach((element) => element.remove());
+        });
+
+        await navigator.clipboard.write([
+          new ClipboardItem({
+            "text/html": new Blob([cloned.innerHTML], {
+              type: "text/html",
+            }),
+            "text/plain": new Blob([content], { type: "text/plain" }),
+          }),
+        ]);
+      } else {
+        await navigator.clipboard.writeText(content);
+      }
+
+      setIsCopied(true);
+      onCopy?.();
+      setTimeout(() => setIsCopied(false), 2000);
+    } catch (error) {
+      console.error("Clipboard API failed, falling back to plain text", error);
+      try {
+        await navigator.clipboard.writeText(content);
+        setIsCopied(true);
+        onCopy?.();
+        setTimeout(() => setIsCopied(false), 2000);
+      } catch (fallbackError) {
+        console.error("Fallback copy also failed:", fallbackError);
+      }
+    }
+  };
+
+  const iconSize = size === "sm" ? "h-3 w-3" : "h-7 w-7";
+  const baseClasses =
+    size === "sm"
+      ? `text-xs px-4 py-2 z-10 rounded-lg hover:cursor-pointer ${className}`
+      : `${iconSize} px-1 py-0.5 text-xs cursor-pointer rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 flex items-center justify-center ${className}`;
+
+  const icon = isCopied ? (
+    <CheckIcon className={iconSize} />
+  ) : (
+    <Square2StackIcon className={iconSize} />
+  );
+
+  return (
+    <button
+      type="button"
+      className={baseClasses}
+      onClick={handleCopy}
+      title={title}
+    >
+      {showLabels ? (
+        <span className="flex items-center gap-1">
+          {icon}
+          {isCopied ? "Copied" : "Copy"}
+        </span>
+      ) : (
+        icon
+      )}
+    </button>
+  );
+};
+
+export default CopyButton;

app/ui/app/src/components/DisplayLogin.tsx

@@ -0,0 +1,74 @@
+import type { ErrorEvent } from "@/gotypes";
+import { Display, type DisplayAction } from "@/components/ui/display";
+import { useUser } from "@/hooks/useUser";
+import { useEffect, useState } from "react";
+
+interface DisplayLoginProps {
+  error: ErrorEvent | null;
+  className?: string;
+  onDismiss?: () => void;
+  message?: string;
+}
+
+export const DisplayLogin = ({
+  error,
+  className,
+  onDismiss,
+  message,
+}: DisplayLoginProps) => {
+  const { fetchConnectUrl, refetchUser, isAuthenticated } = useUser();
+  const [isAwaitingAuth, setIsAwaitingAuth] = useState(false);
+
+  useEffect(() => {
+    const handleFocus = () => {
+      if (isAwaitingAuth) {
+        setIsAwaitingAuth(false);
+        refetchUser();
+      }
+    };
+
+    window.addEventListener("focus", handleFocus);
+
+    return () => {
+      window.removeEventListener("focus", handleFocus);
+    };
+  }, [isAwaitingAuth, refetchUser]);
+
+  useEffect(() => {
+    if (isAuthenticated && isAwaitingAuth) {
+      setIsAwaitingAuth(false);
+      if (onDismiss) {
+        onDismiss();
+      }
+    }
+  }, [isAuthenticated, isAwaitingAuth, onDismiss]);
+
+  if (!error || error.code !== "cloud_unauthorized" || isAuthenticated)
+    return null;
+
+  const handleSignIn = async () => {
+    try {
+      const { data: connectUrl } = await fetchConnectUrl();
+      if (connectUrl) {
+        window.open(connectUrl, "_blank");
+        setIsAwaitingAuth(true);
+      }
+    } catch (error) {
+      console.error("Error getting connect URL:", error);
+    }
+  };
+
+  const action: DisplayAction = {
+    label: "Sign In",
+    onClick: handleSignIn,
+  };
+
+  return (
+    <Display
+      message={message || "Cloud models require an Ollama account"}
+      action={action}
+      className={className}
+      onDismiss={onDismiss}
+    />
+  );
+};