Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
launch: oh-my-pi (#16410)
Bruce MacDonald87cff95af86a
diff --git a/cmd/launch/integrations_test.go b/cmd/launch/integrations_test.goindex 2779928d2..812bc4d07 100644--- a/cmd/launch/integrations_test.go+++ b/cmd/launch/integrations_test.go@@ -65,6 +65,7 @@ func TestIntegrationLookup(t *testing.T) {{"kimi", "kimi", true, "Kimi Code CLI"},{"droid", "droid", true, "Droid"},{"opencode", "opencode", true, "OpenCode"},+ {"omp", "omp", true, "OMP"},{"pool", "pool", true, "Pool"},{"unknown integration", "unknown", false, ""},{"empty string", "", false, ""},@@ -84,7 +85,7 @@ func TestIntegrationLookup(t *testing.T) {}func TestIntegrationRegistry(t *testing.T) {- expectedIntegrations := []string{"claude", "claude-desktop", "cline", "codex", "codex-app", "kimi", "droid", "opencode", "hermes", "hermes-desktop", "pool"}+ expectedIntegrations := []string{"claude", "claude-desktop", "cline", "codex", "codex-app", "kimi", "droid", "opencode", "omp", "hermes", "hermes-desktop", "pool", "qwen"}for _, name := range expectedIntegrations {t.Run(name, func(t *testing.T) {r, ok := integrations[name]@@ -1847,9 +1848,9 @@ func TestListIntegrationInfos(t *testing.T) {for _, info := range infos {got = append(got, info.Name)}- wantPrefix := []string{"claude", "codex-app", "hermes", "openclaw", "opencode", "hermes-desktop", "codex"}+ wantPrefix := []string{"claude", "codex-app", "hermes", "openclaw", "opencode", "hermes-desktop", "codex", "copilot", "omp"}if codexAppSupported() != nil {- wantPrefix = []string{"claude", "hermes", "openclaw", "opencode", "hermes-desktop", "codex"}+ wantPrefix = []string{"claude", "hermes", "openclaw", "opencode", "hermes-desktop", "codex", "copilot", "omp"}}if len(got) < len(wantPrefix) {t.Fatalf("expected at least %d integrations, got %v", len(wantPrefix), got)@@ -1871,7 +1872,7 @@ func TestListIntegrationInfos(t *testing.T) {})t.Run("includes known integrations", func(t *testing.T) {- known := map[string]bool{"claude": false, "cline": false, "codex": false, "opencode": false}+ known := map[string]bool{"claude": false, "cline": false, "codex": false, "opencode": false, "omp": false}if codexAppSupported() == nil {known["codex-app"] = false}@@ -2006,6 +2007,7 @@ func TestIntegration_Editor(t *testing.T) {{"claude", false},{"claude-desktop", false},{"codex", false},+ {"omp", false},{"nonexistent", false},}for _, tt := range tests {@@ -2037,6 +2039,7 @@ func TestIntegration_AutoInstallable(t *testing.T) {{"claude-desktop", false},{"codex", false},{"opencode", false},+ {"omp", false},}for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {diff --git a/cmd/launch/launch.go b/cmd/launch/launch.goindex 82c084e4e..ef5b7f92b 100644--- a/cmd/launch/launch.go+++ b/cmd/launch/launch.go@@ -294,6 +294,7 @@ Supported integrations:codex Codexhermes-desktop Hermes Desktopcopilot Copilot CLI (aliases: copilot-cli)+ omp OMPdroid Droidkimi Kimi Code CLIpi Pidiff --git a/cmd/launch/omp.go b/cmd/launch/omp.gonew file mode 100644index 000000000..10c739f50--- /dev/null+++ b/cmd/launch/omp.go@@ -0,0 +1,454 @@+package launch++import (+ "fmt"+ "os"+ "os/exec"+ "path/filepath"+ "runtime"+ "slices"+ "strings"++ "github.com/ollama/ollama/cmd/config"+ "github.com/ollama/ollama/cmd/internal/fileutil"+ "github.com/ollama/ollama/envconfig"+ "github.com/ollama/ollama/types/model"+ "gopkg.in/yaml.v3"+)++const (+ ompIntegrationName = "omp"+ ompProviderName = "ollama"+ ompSetupVersion = 1+ ompWebSearchPlugin = "@ollama/pi-web-search"+)++// OMP implements Runner for the OMP coding-agent integration.+type OMP struct{}++func (o *OMP) String() string { return "OMP" }++func (o *OMP) Paths() []string {+ var paths []string+ for _, pathFn := range []func() (string, error){ompModelsPath, ompConfigPath} {+ path, err := pathFn()+ if err != nil {+ continue+ }+ if _, err := os.Stat(path); err == nil {+ paths = append(paths, path)+ }+ }+ return paths+}++func (o *OMP) Configure(model string) error {+ return o.ConfigureWithModels(model, []LaunchModel{fallbackLaunchModel(model)})+}++func (o *OMP) ConfigureWithModels(primary string, models []LaunchModel) error {+ if primary == "" {+ return nil+ }+ if len(models) == 0 {+ models = []LaunchModel{fallbackLaunchModel(primary)}+ }+ if err := writeOMPModelsConfig(primary, models); err != nil {+ return err+ }+ return writeOMPAgentConfig()+}++func (o *OMP) CurrentModel() string {+ cfg, err := readOMPModelsConfig()+ if err != nil {+ return ""+ }+ provider, ok := ompProvider(cfg)+ if !ok {+ return ""+ }+ if !ompProviderHealthy(provider) {+ return ""+ }+ models, _ := provider["models"].([]any)+ for _, raw := range models {+ entry, ok := raw.(map[string]any)+ if !ok {+ continue+ }+ if id, _ := entry["id"].(string); id != "" {+ return id+ }+ }+ return ""+}++func (o *OMP) Onboard() error {+ return config.MarkIntegrationOnboarded(ompIntegrationName)+}++func (o *OMP) RequiresInteractiveOnboarding() bool { return false }++func (o *OMP) args(model string, extra []string) []string {+ var args []string+ if model != "" {+ args = append(args, "--model", ompModelName(model))+ }+ args = append(args, extra...)+ return args+}++func ompModelName(model string) string {+ if strings.HasPrefix(model, "ollama/") {+ return model+ }+ return "ollama/" + model+}++func (o *OMP) findPath() (string, error) {+ if p, err := exec.LookPath("omp"); err == nil {+ return p, nil+ }+ home, err := os.UserHomeDir()+ if err != nil {+ return "", err+ }+ for _, dir := range []string{+ filepath.Join(home, ".local", "bin"),+ filepath.Join(home, ".bun", "bin"),+ } {+ for _, name := range ompExecutableNames() {+ fallback := filepath.Join(dir, name)+ if _, err := os.Stat(fallback); err == nil {+ return fallback, nil+ }+ }+ }+ return "", exec.ErrNotFound+}++func ompExecutableNames() []string {+ if runtime.GOOS == "windows" {+ return []string{"omp.exe", "omp.cmd", "omp.bat"}+ }+ return []string{"omp"}+}++func (o *OMP) Run(model string, _ []LaunchModel, args []string) error {+ ompPath, err := o.findPath()+ if err != nil {+ return fmt.Errorf("omp is not installed, install from https://omp.sh")+ }++ ensureOMPWebSearchPlugin(ompPath)++ cmd := exec.Command(ompPath, o.args(model, args)...)+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ cmd.Env = os.Environ()+ return cmd.Run()+}++func ensureOMPWebSearchPlugin(bin string) {+ if !shouldManageOllamaWebSearch() {+ fmt.Fprintf(os.Stderr, "%sCloud is disabled; skipping %s setup.%s\n", ansiGray, ompWebSearchPlugin, ansiReset)+ return+ }++ fmt.Fprintf(os.Stderr, "%sChecking OMP web search plugin...%s\n", ansiGray, ansiReset)++ installed, err := ompPluginInstalled(bin, ompWebSearchPlugin)+ if err != nil {+ fmt.Fprintf(os.Stderr, "%s Warning: could not check %s installation: %v%s\n", ansiYellow, ompWebSearchPlugin, err, ansiReset)+ return+ }++ verb := "Installing"+ warnVerb := "install"+ doneVerb := "Installed"+ if installed {+ verb = "Updating"+ warnVerb = "update"+ doneVerb = "Updated"+ }++ fmt.Fprintf(os.Stderr, "%s%s %s...%s\n", ansiGray, verb, ompWebSearchPlugin, ansiReset)+ cmd := exec.Command(bin, "plugin", "install", ompWebSearchPlugin)+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ if err := cmd.Run(); err != nil {+ fmt.Fprintf(os.Stderr, "%s Warning: could not %s %s: %v%s\n", ansiYellow, warnVerb, ompWebSearchPlugin, err, ansiReset)+ return+ }++ fmt.Fprintf(os.Stderr, "%s ✓ %s %s%s\n", ansiGreen, doneVerb, ompWebSearchPlugin, ansiReset)+}++func ompPluginInstalled(bin, plugin string) (bool, error) {+ cmd := exec.Command(bin, "plugin", "list")+ out, err := cmd.CombinedOutput()+ if err != nil {+ msg := strings.TrimSpace(string(out))+ if msg == "" {+ return false, err+ }+ return false, fmt.Errorf("%w: %s", err, msg)+ }++ versioned := plugin + "@"+ for _, line := range strings.Split(string(out), "\n") {+ trimmed := strings.TrimSpace(line)+ if strings.Contains(trimmed, versioned) || trimmed == plugin {+ return true, nil+ }+ }+ return false, nil+}++func ompModelsPath() (string, error) {+ dir, err := ompAgentDir()+ if err != nil {+ return "", err+ }+ return filepath.Join(dir, "models.yml"), nil+}++func ompConfigPath() (string, error) {+ dir, err := ompAgentDir()+ if err != nil {+ return "", err+ }+ return filepath.Join(dir, "config.yml"), nil+}++func ompAgentDir() (string, error) {+ if dir := strings.TrimSpace(os.Getenv("PI_CODING_AGENT_DIR")); dir != "" {+ return dir, nil+ }++ home, err := os.UserHomeDir()+ if err != nil {+ return "", err+ }+ configDir := strings.TrimSpace(os.Getenv("PI_CONFIG_DIR"))+ if configDir == "" {+ configDir = ".omp"+ }+ if filepath.IsAbs(configDir) {+ return filepath.Join(configDir, "agent"), nil+ }+ return filepath.Join(home, configDir, "agent"), nil+}++func readOMPModelsConfig() (map[string]any, error) {+ path, err := ompModelsPath()+ if err != nil {+ return nil, err+ }+ data, err := os.ReadFile(path)+ if err != nil {+ return nil, err+ }+ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ return nil, err+ }+ if cfg == nil {+ cfg = make(map[string]any)+ }+ return cfg, nil+}++func writeOMPModelsConfig(primary string, models []LaunchModel) error {+ path, err := ompModelsPath()+ if err != nil {+ return err+ }+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return err+ }++ cfg := make(map[string]any)+ if existing, err := readOMPModelsConfig(); err == nil {+ cfg = existing+ }++ provider := ensureOMPProvider(cfg)+ existingByID := ompModelEntriesByID(provider)+ ordered := append([]LaunchModel(nil), models...)+ if model, ok := findLaunchModel(ordered, primary); ok {+ ordered = append([]LaunchModel{model}, removeLaunchModel(ordered, primary)...)+ } else {+ ordered = append([]LaunchModel{fallbackLaunchModel(primary)}, ordered...)+ }++ var merged []any+ seen := make(map[string]bool, len(ordered))+ for _, model := range ordered {+ if model.Name == "" || seen[model.Name] {+ continue+ }+ seen[model.Name] = true+ entry := ompModelConfig(model)+ if existing, ok := existingByID[model.Name]; ok {+ for key, value := range existing {+ if _, overridden := entry[key]; !overridden {+ entry[key] = value+ }+ }+ }+ merged = append(merged, entry)+ }++ for _, raw := range ompProviderModels(provider) {+ entry, ok := raw.(map[string]any)+ if !ok {+ merged = append(merged, raw)+ continue+ }+ id, _ := entry["id"].(string)+ if id == "" || seen[id] {+ continue+ }+ merged = append(merged, entry)+ }+ provider["models"] = merged++ data, err := yaml.Marshal(cfg)+ if err != nil {+ return err+ }+ return fileutil.WriteWithBackup(path, data, ompIntegrationName)+}++func writeOMPAgentConfig() error {+ path, err := ompConfigPath()+ if err != nil {+ return err+ }+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return err+ }++ cfg := make(map[string]any)+ if data, err := os.ReadFile(path); err == nil {+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ return err+ }+ if cfg == nil {+ cfg = make(map[string]any)+ }+ }+ cfg["setupVersion"] = ompSetupVersion++ data, err := yaml.Marshal(cfg)+ if err != nil {+ return err+ }+ return fileutil.WriteWithBackup(path, data, ompIntegrationName)+}++func ensureOMPProvider(cfg map[string]any) map[string]any {+ providers, _ := cfg["providers"].(map[string]any)+ if providers == nil {+ providers = make(map[string]any)+ cfg["providers"] = providers+ }+ provider, _ := providers[ompProviderName].(map[string]any)+ if provider == nil {+ provider = make(map[string]any)+ providers[ompProviderName] = provider+ }++ provider["baseUrl"] = ompBaseURL()+ provider["api"] = "openai-responses"+ provider["auth"] = "none"+ provider["discovery"] = map[string]any{"type": "ollama"}+ return provider+}++func ompBaseURL() string {+ return strings.TrimRight(envconfig.ConnectableHost().String(), "/") + "/v1"+}++func ompProviderHealthy(provider map[string]any) bool {+ baseURL, _ := provider["baseUrl"].(string)+ if strings.TrimRight(baseURL, "/") != strings.TrimRight(ompBaseURL(), "/") {+ return false+ }+ api, _ := provider["api"].(string)+ if api != "openai-responses" {+ return false+ }+ auth, _ := provider["auth"].(string)+ if auth != "none" {+ return false+ }+ discovery, _ := provider["discovery"].(map[string]any)+ if discovery == nil {+ return false+ }+ discoveryType, _ := discovery["type"].(string)+ return discoveryType == "ollama"+}++func ompProvider(cfg map[string]any) (map[string]any, bool) {+ providers, ok := cfg["providers"].(map[string]any)+ if !ok {+ return nil, false+ }+ provider, ok := providers[ompProviderName].(map[string]any)+ return provider, ok+}++func ompProviderModels(provider map[string]any) []any {+ models, _ := provider["models"].([]any)+ return models+}++func ompModelEntriesByID(provider map[string]any) map[string]map[string]any {+ out := make(map[string]map[string]any)+ for _, raw := range ompProviderModels(provider) {+ entry, ok := raw.(map[string]any)+ if !ok {+ continue+ }+ if id, _ := entry["id"].(string); id != "" {+ out[id] = entry+ }+ }+ return out+}++func ompModelConfig(modelInfo LaunchModel) map[string]any {+ entry := map[string]any{+ "id": modelInfo.Name,+ "name": modelInfo.Name,+ }+ input := []string{"text"}+ if slices.Contains(modelInfo.Capabilities, model.CapabilityVision) {+ input = append(input, "image")+ }+ entry["input"] = input++ if modelInfo.ContextLength > 0 {+ entry["contextWindow"] = modelInfo.ContextLength+ }+ if modelInfo.MaxOutputTokens > 0 {+ entry["maxTokens"] = modelInfo.MaxOutputTokens+ }+ return entry+}++func removeLaunchModel(models []LaunchModel, name string) []LaunchModel {+ out := make([]LaunchModel, 0, len(models))+ for _, model := range models {+ if launchModelMatches(model.Name, name) || launchModelMatches(name, model.Name) {+ continue+ }+ out = append(out, model)+ }+ return out+}diff --git a/cmd/launch/omp_test.go b/cmd/launch/omp_test.gonew file mode 100644index 000000000..bc88cb3ef--- /dev/null+++ b/cmd/launch/omp_test.go@@ -0,0 +1,687 @@+package launch++import (+ "fmt"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "runtime"+ "slices"+ "strings"+ "testing"++ modelpkg "github.com/ollama/ollama/types/model"+ "gopkg.in/yaml.v3"+)++func TestMain(m *testing.M) {+ if os.Getenv("OLLAMA_LAUNCH_OMP_TEST_HELPER") == "1" {+ runOMPTestHelper()+ return+ }+ os.Exit(m.Run())+}++func runOMPTestHelper() {+ logPath := os.Getenv("OLLAMA_LAUNCH_OMP_TEST_LOG")+ if logPath != "" {+ f, err := os.OpenFile(logPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644)+ if err == nil {+ _, _ = fmt.Fprintln(f, strings.Join(os.Args[1:], " "))+ _ = f.Close()+ }+ }++ if len(os.Args) >= 3 && os.Args[1] == "plugin" && os.Args[2] == "list" {+ fmt.Print(os.Getenv("OLLAMA_LAUNCH_OMP_TEST_PLUGIN_LIST"))+ os.Exit(0)+ }+ if len(os.Args) >= 4 && os.Args[1] == "plugin" && os.Args[2] == "install" {+ if os.Getenv("OLLAMA_LAUNCH_OMP_TEST_FAIL_INSTALL") == "1" {+ _, _ = fmt.Fprintln(os.Stderr, "install failed")+ os.Exit(1)+ }+ os.Exit(0)+ }+ os.Exit(0)+}++func setOMPTestHome(t *testing.T, dir string) {+ t.Helper()+ setTestHome(t, dir)+ t.Setenv("PI_CONFIG_DIR", "")+ t.Setenv("PI_CODING_AGENT_DIR", "")+}++func TestOMPIntegration(t *testing.T) {+ o := &OMP{}++ t.Run("String", func(t *testing.T) {+ if got := o.String(); got != "OMP" {+ t.Errorf("String() = %q, want %q", got, "OMP")+ }+ })++ t.Run("implements Runner", func(t *testing.T) {+ var _ Runner = o+ })++ t.Run("implements ManagedSingleModel", func(t *testing.T) {+ var _ ManagedSingleModel = o+ })++ t.Run("implements ManagedModelListConfigurer", func(t *testing.T) {+ var _ ManagedModelListConfigurer = o+ })++ t.Run("does not require interactive onboarding", func(t *testing.T) {+ var _ ManagedInteractiveOnboarding = o+ if o.RequiresInteractiveOnboarding() {+ t.Fatal("OMP onboarding should not require an interactive terminal")+ }+ })+}++func TestOMPArgs(t *testing.T) {+ o := &OMP{}++ tests := []struct {+ name string+ model string+ args []string+ want []string+ }{+ {"with model", "gemma4", nil, []string{"--model", "ollama/gemma4"}},+ {"with cloud model", "kimi-k2.6:cloud", nil, []string{"--model", "ollama/kimi-k2.6:cloud"}},+ {"empty model", "", nil, nil},+ {"with model and extra", "gemma4", []string{"--help"}, []string{"--model", "ollama/gemma4", "--help"}},+ {"already qualified", "ollama/gemma4", nil, []string{"--model", "ollama/gemma4"}},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := o.args(tt.model, tt.args)+ if !slices.Equal(got, tt.want) {+ t.Errorf("args(%q, %v) = %v, want %v", tt.model, tt.args, got, tt.want)+ }+ })+ }+}++func TestOMPRun_WebSearchPluginLifecycle(t *testing.T) {+ seedOMPHelperBinary := func(t *testing.T, dir string) {+ t.Helper()+ src, err := os.Executable()+ if err != nil {+ t.Fatal(err)+ }+ data, err := os.ReadFile(src)+ if err != nil {+ t.Fatal(err)+ }+ dst := filepath.Join(dir, ompExecutableNames()[0])+ if err := os.WriteFile(dst, data, 0o755); err != nil {+ t.Fatal(err)+ }+ }++ setCloudStatus := func(t *testing.T, disabled bool) {+ t.Helper()+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/status" {+ fmt.Fprintf(w, `{"cloud":{"disabled":%t,"source":"config"}}`, disabled)+ return+ }+ http.NotFound(w, r)+ }))+ t.Cleanup(srv.Close)+ t.Setenv("OLLAMA_HOST", srv.URL)+ }++ setup := func(t *testing.T, pluginList string, cloudDisabled bool) (string, *OMP) {+ t.Helper()+ tmpDir := t.TempDir()+ setOMPTestHome(t, tmpDir)+ t.Setenv("PATH", tmpDir)+ t.Setenv("OLLAMA_LAUNCH_OMP_TEST_HELPER", "1")+ t.Setenv("OLLAMA_LAUNCH_OMP_TEST_PLUGIN_LIST", pluginList)+ logPath := filepath.Join(tmpDir, "omp.log")+ t.Setenv("OLLAMA_LAUNCH_OMP_TEST_LOG", logPath)+ setCloudStatus(t, cloudDisabled)+ seedOMPHelperBinary(t, tmpDir)+ return logPath, &OMP{}+ }++ t.Run("web search missing installs before launch", func(t *testing.T) {+ logPath, o := setup(t, "No plugins installed\n", false)++ if err := o.Run("kimi-k2.6:cloud", nil, []string{"session"}); err != nil {+ t.Fatalf("Run() error = %v", err)+ }++ calls, err := os.ReadFile(logPath)+ if err != nil {+ t.Fatal(err)+ }+ got := string(calls)+ if !strings.Contains(got, "plugin list\n") {+ t.Fatalf("expected plugin list call, got:\n%s", got)+ }+ if !strings.Contains(got, "plugin install "+ompWebSearchPlugin+"\n") {+ t.Fatalf("expected plugin install call, got:\n%s", got)+ }+ if !strings.Contains(got, "--model ollama/kimi-k2.6:cloud session\n") {+ t.Fatalf("expected final omp launch call, got:\n%s", got)+ }+ })++ t.Run("web search present refreshes before launch", func(t *testing.T) {+ logPath, o := setup(t, "npm Plugins:\n\n● "+ompWebSearchPlugin+"@0.0.5\n", false)++ if err := o.Run("gemma4", nil, []string{"chat"}); err != nil {+ t.Fatalf("Run() error = %v", err)+ }++ calls, err := os.ReadFile(logPath)+ if err != nil {+ t.Fatal(err)+ }+ got := string(calls)+ if !strings.Contains(got, "plugin install "+ompWebSearchPlugin+"\n") {+ t.Fatalf("expected plugin refresh install call, got:\n%s", got)+ }+ if !strings.Contains(got, "--model ollama/gemma4 chat\n") {+ t.Fatalf("expected final omp launch call, got:\n%s", got)+ }+ })++ t.Run("web search install failure warns and continues", func(t *testing.T) {+ logPath, o := setup(t, "No plugins installed\n", false)+ t.Setenv("OLLAMA_LAUNCH_OMP_TEST_FAIL_INSTALL", "1")++ stderr := captureStderr(t, func() {+ if err := o.Run("gemma4", nil, []string{"chat"}); err != nil {+ t.Fatalf("Run() should continue after plugin install failure, got %v", err)+ }+ })+ if !strings.Contains(stderr, "Warning: could not install "+ompWebSearchPlugin) {+ t.Fatalf("expected install warning, got:\n%s", stderr)+ }++ calls, err := os.ReadFile(logPath)+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(string(calls), "--model ollama/gemma4 chat\n") {+ t.Fatalf("expected final omp launch call, got:\n%s", calls)+ }+ })++ t.Run("cloud disabled skips web search plugin management", func(t *testing.T) {+ logPath, o := setup(t, "No plugins installed\n", true)++ stderr := captureStderr(t, func() {+ if err := o.Run("gemma4", nil, []string{"chat"}); err != nil {+ t.Fatalf("Run() error = %v", err)+ }+ })+ if !strings.Contains(stderr, "Cloud is disabled; skipping "+ompWebSearchPlugin+" setup.") {+ t.Fatalf("expected cloud-disabled skip message, got:\n%s", stderr)+ }++ calls, err := os.ReadFile(logPath)+ if err != nil {+ t.Fatal(err)+ }+ got := string(calls)+ if strings.Contains(got, "plugin list\n") || strings.Contains(got, "plugin install "+ompWebSearchPlugin+"\n") {+ t.Fatalf("did not expect plugin management calls, got:\n%s", got)+ }+ if !strings.Contains(got, "--model ollama/gemma4 chat\n") {+ t.Fatalf("expected final omp launch call, got:\n%s", got)+ }+ })+}++func TestOMPFindPath(t *testing.T) {+ o := &OMP{}++ t.Run("finds omp in PATH", func(t *testing.T) {+ tmpDir := t.TempDir()+ name := "omp"+ if runtime.GOOS == "windows" {+ name = "omp.exe"+ }+ fakeBin := filepath.Join(tmpDir, name)+ os.WriteFile(fakeBin, []byte("#!/bin/sh\n"), 0o755)+ t.Setenv("PATH", tmpDir)++ got, err := o.findPath()+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if got != fakeBin {+ t.Errorf("findPath() = %q, want %q", got, fakeBin)+ }+ })++ t.Run("falls back to ~/.local/bin/omp", func(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("PATH", t.TempDir())++ fallback := filepath.Join(home, ".local", "bin", ompExecutableNames()[0])+ os.MkdirAll(filepath.Dir(fallback), 0o755)+ os.WriteFile(fallback, []byte("#!/bin/sh\n"), 0o755)++ got, err := o.findPath()+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if got != fallback {+ t.Errorf("findPath() = %q, want %q", got, fallback)+ }+ })++ t.Run("falls back to ~/.bun/bin/omp", func(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("PATH", t.TempDir())++ fallback := filepath.Join(home, ".bun", "bin", ompExecutableNames()[0])+ os.MkdirAll(filepath.Dir(fallback), 0o755)+ os.WriteFile(fallback, []byte("#!/bin/sh\n"), 0o755)++ got, err := o.findPath()+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if got != fallback {+ t.Errorf("findPath() = %q, want %q", got, fallback)+ }+ })++ t.Run("returns error when not found", func(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("PATH", t.TempDir())++ if _, err := o.findPath(); err == nil {+ t.Fatal("expected error, got nil")+ }+ })+}++func TestOMPConfigureWithModelsWritesModelsYML(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("OLLAMA_HOST", "http://0.0.0.0:11434")++ o := &OMP{}+ models := []LaunchModel{+ {+ Name: "glm-5.1:cloud",+ ContextLength: 202_752,+ MaxOutputTokens: 131_072,+ },+ {+ Name: "qwen3.6",+ Capabilities: []modelpkg.Capability{modelpkg.CapabilityVision},+ },+ }+ if err := o.ConfigureWithModels("glm-5.1:cloud", models); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ path := filepath.Join(home, ".omp", "agent", "models.yml")+ data, err := os.ReadFile(path)+ if err != nil {+ t.Fatalf("failed to read models.yml: %v", err)+ }++ cfg := parseOMPConfigYAML(t, data)+ provider := ompProviderFromYAML(t, cfg)+ if provider["baseUrl"] != "http://127.0.0.1:11434/v1" {+ t.Fatalf("baseUrl = %v, want connectable OpenAI-compatible host", provider["baseUrl"])+ }+ if provider["api"] != "openai-responses" {+ t.Fatalf("api = %v, want openai-responses", provider["api"])+ }+ if provider["auth"] != "none" {+ t.Fatalf("auth = %v, want none", provider["auth"])+ }+ discovery, _ := provider["discovery"].(map[string]any)+ if discovery["type"] != "ollama" {+ t.Fatalf("discovery = %v, want type ollama", discovery)+ }++ entries := ompModelEntriesFromYAML(t, provider)+ if len(entries) != 2 {+ t.Fatalf("models length = %d, want 2", len(entries))+ }+ if entries[0]["id"] != "glm-5.1:cloud" {+ t.Fatalf("first model id = %v, want primary first", entries[0]["id"])+ }+ if got := numericYAMLValue(entries[0]["contextWindow"]); got != 202_752 {+ t.Fatalf("contextWindow = %d, want 202752", got)+ }+ if got := numericYAMLValue(entries[0]["maxTokens"]); got != 131_072 {+ t.Fatalf("maxTokens = %d, want 131072", got)+ }+ if input := stringSliceYAMLValue(entries[1]["input"]); !slices.Equal(input, []string{"text", "image"}) {+ t.Fatalf("vision input = %v, want [text image]", input)+ }+ if got := o.CurrentModel(); got != "glm-5.1:cloud" {+ t.Fatalf("CurrentModel = %q, want glm-5.1:cloud", got)+ }++ configPath := filepath.Join(home, ".omp", "agent", "config.yml")+ configData, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatalf("failed to read config.yml: %v", err)+ }+ config := parseOMPConfigYAML(t, configData)+ if got := numericYAMLValue(config["setupVersion"]); got != ompSetupVersion {+ t.Fatalf("setupVersion = %d, want %d", got, ompSetupVersion)+ }+ if paths := o.Paths(); !slices.Equal(paths, []string{path, configPath}) {+ t.Fatalf("Paths = %v, want [%s %s]", paths, path, configPath)+ }+}++func TestOMPConfigureWithModelsPreservesExistingConfig(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)++ modelsPath := filepath.Join(home, ".omp", "agent", "models.yml")+ if err := os.MkdirAll(filepath.Dir(modelsPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := []byte(`+providers:+ anthropic:+ baseUrl: https://example.com/anthropic+ ollama:+ baseUrl: http://old-host:11434+ api: openai-responses+ auth: none+ models:+ - id: old-model+ name: Old Model+ customField: keep-me+`)+ if err := os.WriteFile(modelsPath, existing, 0o644); err != nil {+ t.Fatal(err)+ }++ configPath := filepath.Join(home, ".omp", "agent", "config.yml")+ existingConfig := []byte(`+lastChangelogVersion: 15.7.6+setupVersion: 0+theme: monochrome+`)+ if err := os.WriteFile(configPath, existingConfig, 0o644); err != nil {+ t.Fatal(err)+ }++ o := &OMP{}+ if err := o.ConfigureWithModels("new-model", []LaunchModel{{Name: "new-model"}, {Name: "old-model"}}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ data, err := os.ReadFile(modelsPath)+ if err != nil {+ t.Fatal(err)+ }+ cfg := parseOMPConfigYAML(t, data)+ providers, _ := cfg["providers"].(map[string]any)+ if _, ok := providers["anthropic"]; !ok {+ t.Fatalf("expected non-Ollama provider to be preserved: %v", providers)+ }++ provider := ompProviderFromYAML(t, cfg)+ if provider["baseUrl"] != "http://127.0.0.1:11434/v1" {+ t.Fatalf("baseUrl = %v, want repaired OpenAI-compatible host", provider["baseUrl"])+ }++ entries := ompModelEntriesFromYAML(t, provider)+ if len(entries) != 2 {+ t.Fatalf("models length = %d, want 2", len(entries))+ }+ if entries[0]["id"] != "new-model" {+ t.Fatalf("first model id = %v, want new-model", entries[0]["id"])+ }+ if entries[1]["id"] != "old-model" {+ t.Fatalf("second model id = %v, want old-model", entries[1]["id"])+ }+ if entries[1]["customField"] != "keep-me" {+ t.Fatalf("custom field was not preserved: %v", entries[1])+ }++ configData, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ config := parseOMPConfigYAML(t, configData)+ if got := numericYAMLValue(config["setupVersion"]); got != ompSetupVersion {+ t.Fatalf("setupVersion = %d, want %d", got, ompSetupVersion)+ }+ if config["theme"] != "monochrome" {+ t.Fatalf("theme was not preserved: %v", config)+ }+ if config["lastChangelogVersion"] != "15.7.6" {+ t.Fatalf("lastChangelogVersion was not preserved: %v", config)+ }+}++func TestOMPConfigureWithModelsAlwaysMarksSetupComplete(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)++ configPath := filepath.Join(home, ".omp", "agent", "config.yml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(configPath, []byte("setupVersion: 2\n"), 0o644); err != nil {+ t.Fatal(err)+ }++ o := &OMP{}+ if err := o.ConfigureWithModels("new-model", []LaunchModel{{Name: "new-model"}}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ configData, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ config := parseOMPConfigYAML(t, configData)+ if got := numericYAMLValue(config["setupVersion"]); got != ompSetupVersion {+ t.Fatalf("setupVersion = %d, want %d", got, ompSetupVersion)+ }+}++func TestOMPConfigureWithModelsRespectsPiConfigDir(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("PI_CONFIG_DIR", ".custom-omp")++ o := &OMP{}+ if err := o.ConfigureWithModels("new-model", []LaunchModel{{Name: "new-model"}}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ modelsPath := filepath.Join(home, ".custom-omp", "agent", "models.yml")+ configPath := filepath.Join(home, ".custom-omp", "agent", "config.yml")+ for _, path := range []string{modelsPath, configPath} {+ if _, err := os.Stat(path); err != nil {+ t.Fatalf("expected %s to be written: %v", path, err)+ }+ }+ if _, err := os.Stat(filepath.Join(home, ".omp", "agent", "models.yml")); !os.IsNotExist(err) {+ t.Fatalf("expected default OMP models path to be untouched, got err %v", err)+ }+ if paths := o.Paths(); !slices.Equal(paths, []string{modelsPath, configPath}) {+ t.Fatalf("Paths = %v, want [%s %s]", paths, modelsPath, configPath)+ }+}++func TestOMPConfigureWithModelsRespectsPiCodingAgentDir(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ agentDir := filepath.Join(home, "agent-override")+ t.Setenv("PI_CONFIG_DIR", ".ignored-omp")+ t.Setenv("PI_CODING_AGENT_DIR", agentDir)++ o := &OMP{}+ if err := o.ConfigureWithModels("new-model", []LaunchModel{{Name: "new-model"}}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ modelsPath := filepath.Join(agentDir, "models.yml")+ configPath := filepath.Join(agentDir, "config.yml")+ for _, path := range []string{modelsPath, configPath} {+ if _, err := os.Stat(path); err != nil {+ t.Fatalf("expected %s to be written: %v", path, err)+ }+ }+ if _, err := os.Stat(filepath.Join(home, ".ignored-omp", "agent", "models.yml")); !os.IsNotExist(err) {+ t.Fatalf("expected PI_CONFIG_DIR path to be ignored when PI_CODING_AGENT_DIR is set, got err %v", err)+ }+ if got := o.CurrentModel(); got != "new-model" {+ t.Fatalf("CurrentModel = %q, want new-model", got)+ }+}++func TestOMPCurrentModelRequiresHealthyProvider(t *testing.T) {+ home := t.TempDir()+ setOMPTestHome(t, home)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:11434")++ modelsPath := filepath.Join(home, ".omp", "agent", "models.yml")+ if err := os.MkdirAll(filepath.Dir(modelsPath), 0o755); err != nil {+ t.Fatal(err)+ }++ tests := []struct {+ name string+ provider string+ }{+ {+ name: "wrong base url",+ provider: "" ++ " baseUrl: http://127.0.0.1:9999/v1\n" ++ " api: openai-responses\n" ++ " auth: none\n" ++ " discovery:\n" ++ " type: ollama\n",+ },+ {+ name: "wrong api",+ provider: "" ++ " baseUrl: http://127.0.0.1:11434/v1\n" ++ " api: openai-chat\n" ++ " auth: none\n" ++ " discovery:\n" ++ " type: ollama\n",+ },+ {+ name: "wrong auth",+ provider: "" ++ " baseUrl: http://127.0.0.1:11434/v1\n" ++ " api: openai-responses\n" ++ " auth: api-key\n" ++ " discovery:\n" ++ " type: ollama\n",+ },+ {+ name: "wrong discovery",+ provider: "" ++ " baseUrl: http://127.0.0.1:11434/v1\n" ++ " api: openai-responses\n" ++ " auth: none\n" ++ " discovery:\n" ++ " type: static\n",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ cfg := "providers:\n" ++ " ollama:\n" ++ tt.provider ++ " models:\n" ++ " - id: gemma4\n"+ if err := os.WriteFile(modelsPath, []byte(cfg), 0o644); err != nil {+ t.Fatal(err)+ }+ if got := (&OMP{}).CurrentModel(); got != "" {+ t.Fatalf("expected stale config to return empty current model, got %q", got)+ }+ })+ }+}++func parseOMPConfigYAML(t *testing.T, data []byte) map[string]any {+ t.Helper()+ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("generated YAML did not parse: %v\n%s", err, data)+ }+ return cfg+}++func ompProviderFromYAML(t *testing.T, cfg map[string]any) map[string]any {+ t.Helper()+ providers, ok := cfg["providers"].(map[string]any)+ if !ok {+ t.Fatalf("providers missing from config: %v", cfg)+ }+ provider, ok := providers["ollama"].(map[string]any)+ if !ok {+ t.Fatalf("ollama provider missing from config: %v", providers)+ }+ return provider+}++func ompModelEntriesFromYAML(t *testing.T, provider map[string]any) []map[string]any {+ t.Helper()+ rawModels, ok := provider["models"].([]any)+ if !ok {+ t.Fatalf("provider models missing: %v", provider)+ }+ models := make([]map[string]any, 0, len(rawModels))+ for _, raw := range rawModels {+ entry, ok := raw.(map[string]any)+ if !ok {+ t.Fatalf("model entry has unexpected type %T: %v", raw, raw)+ }+ models = append(models, entry)+ }+ return models+}++func numericYAMLValue(value any) int {+ switch v := value.(type) {+ case int:+ return v+ case int64:+ return int(v)+ case float64:+ return int(v)+ default:+ return 0+ }+}++func stringSliceYAMLValue(value any) []string {+ raw, _ := value.([]any)+ out := make([]string, 0, len(raw))+ for _, item := range raw {+ if s, ok := item.(string); ok {+ out = append(out, s)+ }+ }+ return out+}diff --git a/cmd/launch/pi.go b/cmd/launch/pi.goindex 2854d6b06..ee8d783bb 100644--- a/cmd/launch/pi.go+++ b/cmd/launch/pi.go@@ -351,7 +351,7 @@ func npmArgs(prefix string, args ...string) []string {}func ensurePiWebSearchPackage(bin string) {- if !shouldManagePiWebSearch() {+ if !shouldManageOllamaWebSearch() {fmt.Fprintf(os.Stderr, "%sCloud is disabled; skipping %s setup.%s\n", ansiGray, piWebSearchPkg, ansiReset)return}@@ -395,7 +395,7 @@ func ensurePiWebSearchPackage(bin string) {fmt.Fprintf(os.Stderr, "%s ✓ Updated %s%s\n", ansiGreen, piWebSearchPkg, ansiReset)}-func shouldManagePiWebSearch() bool {+func shouldManageOllamaWebSearch() bool {client, err := api.ClientFromEnvironment()if err != nil {return truediff --git a/cmd/launch/registry.go b/cmd/launch/registry.goindex 143926128..613b916ab 100644--- a/cmd/launch/registry.go+++ b/cmd/launch/registry.go@@ -33,7 +33,7 @@ type IntegrationInfo struct {Description string}-var launcherIntegrationOrder = []string{"claude", "codex-app", "hermes", "openclaw", "opencode", "hermes-desktop", "codex", "copilot", "cline", "droid", "pi", "pool", "qwen"}+var launcherIntegrationOrder = []string{"claude", "codex-app", "hermes", "openclaw", "opencode", "hermes-desktop", "codex", "copilot", "omp", "cline", "droid", "pi", "pool", "qwen"}var integrationSpecs = []*IntegrationSpec{{@@ -156,6 +156,18 @@ var integrationSpecs = []*IntegrationSpec{URL: "https://opencode.ai",},},+ {+ Name: "omp",+ Runner: &OMP{},+ Description: "AI coding agent with IDE integration",+ Install: IntegrationInstallSpec{+ CheckInstalled: func() bool {+ _, err := (&OMP{}).findPath()+ return err == nil+ },+ URL: "https://omp.sh",+ },+ },{Name: "openclaw",Runner: &Openclaw{},diff --git a/cmd/launch/runner_exec_only_test.go b/cmd/launch/runner_exec_only_test.goindex 06a5d6554..fb8c6e918 100644--- a/cmd/launch/runner_exec_only_test.go+++ b/cmd/launch/runner_exec_only_test.go@@ -61,6 +61,14 @@ func TestEditorRunsDoNotRewriteConfig(t *testing.T) {return filepath.Join(home, ".kimi", "config.toml")},},+ {+ name: "omp",+ binary: "omp",+ runner: &OMP{},+ checkPath: func(home string) string {+ return filepath.Join(home, ".omp", "agent", "models.yml")+ },+ },}for _, tt := range tests {