Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
cmd: ollama launch pi (#14084)
Parth Sareen5ef04dab5293
diff --git a/cmd/config/integrations.go b/cmd/config/integrations.goindex 2193a135c..e268ade38 100644--- a/cmd/config/integrations.go+++ b/cmd/config/integrations.go@@ -60,6 +60,7 @@ var integrations = map[string]Runner{"droid": &Droid{},"opencode": &OpenCode{},"openclaw": &Openclaw{},+ "pi": &Pi{},}// recommendedModels are shown when the user has no models or as suggestions.diff --git a/cmd/config/pi.go b/cmd/config/pi.gonew file mode 100644index 000000000..9dd84ee87--- /dev/null+++ b/cmd/config/pi.go@@ -0,0 +1,237 @@+package config++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "os"+ "os/exec"+ "path/filepath"+ "slices"+ "strings"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/envconfig"+ "github.com/ollama/ollama/types/model"+)++// Pi implements Runner and Editor for Pi (Pi Coding Agent) integration+type Pi struct{}++func (p *Pi) String() string { return "Pi" }++func (p *Pi) Run(model string, args []string) error {+ if _, err := exec.LookPath("pi"); err != nil {+ return fmt.Errorf("pi is not installed, install with: npm install -g @mariozechner/pi-coding-agent")+ }++ // Call Edit() to ensure config is up-to-date before launch+ models := []string{model}+ if config, err := loadIntegration("pi"); err == nil && len(config.Models) > 0 {+ models = config.Models+ }+ if err := p.Edit(models); err != nil {+ return fmt.Errorf("setup failed: %w", err)+ }++ cmd := exec.Command("pi", args...)+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd.Run()+}++func (p *Pi) Paths() []string {+ home, err := os.UserHomeDir()+ if err != nil {+ return nil+ }++ var paths []string+ modelsPath := filepath.Join(home, ".pi", "agent", "models.json")+ if _, err := os.Stat(modelsPath); err == nil {+ paths = append(paths, modelsPath)+ }+ settingsPath := filepath.Join(home, ".pi", "agent", "settings.json")+ if _, err := os.Stat(settingsPath); err == nil {+ paths = append(paths, settingsPath)+ }+ return paths+}++func (p *Pi) Edit(models []string) error {+ if len(models) == 0 {+ return nil+ }++ home, err := os.UserHomeDir()+ if err != nil {+ return err+ }++ configPath := filepath.Join(home, ".pi", "agent", "models.json")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ return err+ }++ config := make(map[string]any)+ if data, err := os.ReadFile(configPath); err == nil {+ _ = json.Unmarshal(data, &config)+ }++ providers, ok := config["providers"].(map[string]any)+ if !ok {+ providers = make(map[string]any)+ }++ ollama, ok := providers["ollama"].(map[string]any)+ if !ok {+ ollama = map[string]any{+ "baseUrl": envconfig.Host().String() + "/v1",+ "api": "openai-completions",+ "apiKey": "ollama",+ }+ }++ existingModels, ok := ollama["models"].([]any)+ if !ok {+ existingModels = make([]any, 0)+ }++ // Build set of selected models to track which need to be added+ selectedSet := make(map[string]bool, len(models))+ for _, m := range models {+ selectedSet[m] = true+ }++ // Build new models list:+ // 1. Keep user-managed models (no _launch marker) - untouched+ // 2. Keep ollama-managed models (_launch marker) that are still selected+ // 3. Add new ollama-managed models+ var newModels []any+ for _, m := range existingModels {+ if modelObj, ok := m.(map[string]any); ok {+ if id, ok := modelObj["id"].(string); ok {+ // User-managed model (no _launch marker) - always preserve+ if !isPiOllamaModel(modelObj) {+ newModels = append(newModels, m)+ } else if selectedSet[id] {+ // Ollama-managed and still selected - keep it+ newModels = append(newModels, m)+ selectedSet[id] = false+ }+ }+ }+ }++ // Add newly selected models that weren't already in the list+ client := api.NewClient(envconfig.Host(), http.DefaultClient)+ ctx := context.Background()+ for _, model := range models {+ if selectedSet[model] {+ newModels = append(newModels, createConfig(ctx, client, model))+ }+ }++ ollama["models"] = newModels+ providers["ollama"] = ollama+ config["providers"] = providers++ configData, err := json.MarshalIndent(config, "", " ")+ if err != nil {+ return err+ }+ if err := writeWithBackup(configPath, configData); err != nil {+ return err+ }++ // Update settings.json with default provider and model+ settingsPath := filepath.Join(home, ".pi", "agent", "settings.json")+ settings := make(map[string]any)+ if data, err := os.ReadFile(settingsPath); err == nil {+ _ = json.Unmarshal(data, &settings)+ }++ settings["defaultProvider"] = "ollama"+ settings["defaultModel"] = models[0]++ settingsData, err := json.MarshalIndent(settings, "", " ")+ if err != nil {+ return err+ }+ return writeWithBackup(settingsPath, settingsData)+}++func (p *Pi) Models() []string {+ home, err := os.UserHomeDir()+ if err != nil {+ return nil+ }++ configPath := filepath.Join(home, ".pi", "agent", "models.json")+ config, err := readJSONFile(configPath)+ if err != nil {+ return nil+ }++ providers, _ := config["providers"].(map[string]any)+ ollama, _ := providers["ollama"].(map[string]any)+ models, _ := ollama["models"].([]any)++ var result []string+ for _, m := range models {+ if modelObj, ok := m.(map[string]any); ok {+ if id, ok := modelObj["id"].(string); ok {+ result = append(result, id)+ }+ }+ }+ slices.Sort(result)+ return result+}++// isPiOllamaModel reports whether a model config entry is managed by ollama launch+func isPiOllamaModel(cfg map[string]any) bool {+ if v, ok := cfg["_launch"].(bool); ok && v {+ return true+ }+ return false+}++// createConfig builds Pi model config with capability detection+func createConfig(ctx context.Context, client *api.Client, modelID string) map[string]any {+ cfg := map[string]any{+ "id": modelID,+ "_launch": true,+ }++ resp, err := client.Show(ctx, &api.ShowRequest{Model: modelID})+ if err != nil {+ return cfg+ }++ // Set input types based on vision capability+ if slices.Contains(resp.Capabilities, model.CapabilityVision) {+ cfg["input"] = []string{"text", "image"}+ } else {+ cfg["input"] = []string{"text"}+ }++ // Set reasoning based on thinking capability+ if slices.Contains(resp.Capabilities, model.CapabilityThinking) {+ cfg["reasoning"] = true+ }++ // Extract context window from ModelInfo+ for key, val := range resp.ModelInfo {+ if strings.HasSuffix(key, ".context_length") {+ if ctxLen, ok := val.(float64); ok && ctxLen > 0 {+ cfg["contextWindow"] = int(ctxLen)+ }+ break+ }+ }++ return cfg+}diff --git a/cmd/config/pi_test.go b/cmd/config/pi_test.gonew file mode 100644index 000000000..18c62be94--- /dev/null+++ b/cmd/config/pi_test.go@@ -0,0 +1,830 @@+package config++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "net/url"+ "os"+ "path/filepath"+ "testing"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/types/model"+)++func TestPiIntegration(t *testing.T) {+ pi := &Pi{}++ t.Run("String", func(t *testing.T) {+ if got := pi.String(); got != "Pi" {+ t.Errorf("String() = %q, want %q", got, "Pi")+ }+ })++ t.Run("implements Runner", func(t *testing.T) {+ var _ Runner = pi+ })++ t.Run("implements Editor", func(t *testing.T) {+ var _ Editor = pi+ })+}++func TestPiPaths(t *testing.T) {+ pi := &Pi{}++ t.Run("returns empty when no config exists", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ paths := pi.Paths()+ if len(paths) != 0 {+ t.Errorf("Paths() = %v, want empty", paths)+ }+ })++ t.Run("returns path when config exists", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ if err := os.MkdirAll(configDir, 0o755); err != nil {+ t.Fatal(err)+ }+ configPath := filepath.Join(configDir, "models.json")+ if err := os.WriteFile(configPath, []byte("{}"), 0o644); err != nil {+ t.Fatal(err)+ }++ paths := pi.Paths()+ if len(paths) != 1 || paths[0] != configPath {+ t.Errorf("Paths() = %v, want [%s]", paths, configPath)+ }+ })+}++func TestPiEdit(t *testing.T) {+ // Mock Ollama server for createConfig calls during Edit+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":[],"model_info":{}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ pi := &Pi{}+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ configPath := filepath.Join(configDir, "models.json")++ cleanup := func() {+ os.RemoveAll(configDir)+ }++ readConfig := func() map[string]any {+ data, _ := os.ReadFile(configPath)+ var cfg map[string]any+ json.Unmarshal(data, &cfg)+ return cfg+ }++ t.Run("returns nil for empty models", func(t *testing.T) {+ if err := pi.Edit([]string{}); err != nil {+ t.Errorf("Edit([]) error = %v, want nil", err)+ }+ })++ t.Run("creates config with models", func(t *testing.T) {+ cleanup()++ models := []string{"llama3.2", "qwen3:8b"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ cfg := readConfig()++ providers, ok := cfg["providers"].(map[string]any)+ if !ok {+ t.Error("Config missing providers")+ }++ ollama, ok := providers["ollama"].(map[string]any)+ if !ok {+ t.Error("Providers missing ollama")+ }++ modelsArray, ok := ollama["models"].([]any)+ if !ok || len(modelsArray) != 2 {+ t.Errorf("Expected 2 models, got %v", modelsArray)+ }++ if ollama["baseUrl"] == nil {+ t.Error("Missing baseUrl")+ }+ if ollama["api"] != "openai-completions" {+ t.Errorf("Expected api=openai-completions, got %v", ollama["api"])+ }+ if ollama["apiKey"] != "ollama" {+ t.Errorf("Expected apiKey=ollama, got %v", ollama["apiKey"])+ }+ })++ t.Run("updates existing config preserving ollama provider settings", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ existingConfig := `{+ "providers": {+ "ollama": {+ "baseUrl": "http://custom:8080/v1",+ "api": "custom-api",+ "apiKey": "custom-key",+ "models": [+ {"id": "old-model", "_launch": true}+ ]+ }+ }+ }`+ if err := os.WriteFile(configPath, []byte(existingConfig), 0o644); err != nil {+ t.Fatal(err)+ }++ models := []string{"new-model"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ cfg := readConfig()+ providers := cfg["providers"].(map[string]any)+ ollama := providers["ollama"].(map[string]any)++ if ollama["baseUrl"] != "http://custom:8080/v1" {+ t.Errorf("Custom baseUrl not preserved, got %v", ollama["baseUrl"])+ }+ if ollama["api"] != "custom-api" {+ t.Errorf("Custom api not preserved, got %v", ollama["api"])+ }+ if ollama["apiKey"] != "custom-key" {+ t.Errorf("Custom apiKey not preserved, got %v", ollama["apiKey"])+ }++ modelsArray := ollama["models"].([]any)+ if len(modelsArray) != 1 {+ t.Errorf("Expected 1 model after update, got %d", len(modelsArray))+ } else {+ modelEntry := modelsArray[0].(map[string]any)+ if modelEntry["id"] != "new-model" {+ t.Errorf("Expected new-model, got %v", modelEntry["id"])+ }+ // Verify _launch marker is present+ if modelEntry["_launch"] != true {+ t.Errorf("Expected _launch marker to be true")+ }+ }+ })++ t.Run("replaces old models with new ones", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ // Old models must have _launch marker to be managed by us+ existingConfig := `{+ "providers": {+ "ollama": {+ "baseUrl": "http://localhost:11434/v1",+ "api": "openai-completions",+ "apiKey": "ollama",+ "models": [+ {"id": "old-model-1", "_launch": true},+ {"id": "old-model-2", "_launch": true}+ ]+ }+ }+ }`+ if err := os.WriteFile(configPath, []byte(existingConfig), 0o644); err != nil {+ t.Fatal(err)+ }++ newModels := []string{"new-model-1", "new-model-2"}+ if err := pi.Edit(newModels); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ cfg := readConfig()+ providers := cfg["providers"].(map[string]any)+ ollama := providers["ollama"].(map[string]any)+ modelsArray := ollama["models"].([]any)++ if len(modelsArray) != 2 {+ t.Errorf("Expected 2 models, got %d", len(modelsArray))+ }++ modelIDs := make(map[string]bool)+ for _, m := range modelsArray {+ modelObj := m.(map[string]any)+ id := modelObj["id"].(string)+ modelIDs[id] = true+ }++ if !modelIDs["new-model-1"] || !modelIDs["new-model-2"] {+ t.Errorf("Expected new models, got %v", modelIDs)+ }+ if modelIDs["old-model-1"] || modelIDs["old-model-2"] {+ t.Errorf("Old models should have been removed, got %v", modelIDs)+ }+ })++ t.Run("handles partial overlap in model list", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ // Models must have _launch marker to be managed+ existingConfig := `{+ "providers": {+ "ollama": {+ "baseUrl": "http://localhost:11434/v1",+ "api": "openai-completions",+ "apiKey": "ollama",+ "models": [+ {"id": "keep-model", "_launch": true},+ {"id": "remove-model", "_launch": true}+ ]+ }+ }+ }`+ if err := os.WriteFile(configPath, []byte(existingConfig), 0o644); err != nil {+ t.Fatal(err)+ }++ newModels := []string{"keep-model", "add-model"}+ if err := pi.Edit(newModels); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ cfg := readConfig()+ providers := cfg["providers"].(map[string]any)+ ollama := providers["ollama"].(map[string]any)+ modelsArray := ollama["models"].([]any)++ if len(modelsArray) != 2 {+ t.Errorf("Expected 2 models, got %d", len(modelsArray))+ }++ modelIDs := make(map[string]bool)+ for _, m := range modelsArray {+ modelObj := m.(map[string]any)+ id := modelObj["id"].(string)+ modelIDs[id] = true+ }++ if !modelIDs["keep-model"] || !modelIDs["add-model"] {+ t.Errorf("Expected keep-model and add-model, got %v", modelIDs)+ }+ if modelIDs["remove-model"] {+ t.Errorf("remove-model should have been removed")+ }+ })++ t.Run("handles corrupt config gracefully", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ if err := os.WriteFile(configPath, []byte("{invalid json}"), 0o644); err != nil {+ t.Fatal(err)+ }++ models := []string{"test-model"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() should not fail with corrupt config, got %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatalf("Failed to read config: %v", err)+ }++ var cfg map[string]any+ if err := json.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("Config should be valid after Edit, got parse error: %v", err)+ }++ providers := cfg["providers"].(map[string]any)+ ollama := providers["ollama"].(map[string]any)+ modelsArray := ollama["models"].([]any)++ if len(modelsArray) != 1 {+ t.Errorf("Expected 1 model, got %d", len(modelsArray))+ }+ })++ // CRITICAL SAFETY TEST: verifies we don't stomp on user configs+ t.Run("preserves user-managed models without _launch marker", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ // User has manually configured models in ollama provider (no _launch marker)+ existingConfig := `{+ "providers": {+ "ollama": {+ "baseUrl": "http://localhost:11434/v1",+ "api": "openai-completions",+ "apiKey": "ollama",+ "models": [+ {"id": "user-model-1"},+ {"id": "user-model-2", "customField": "preserved"},+ {"id": "ollama-managed", "_launch": true}+ ]+ }+ }+ }`+ if err := os.WriteFile(configPath, []byte(existingConfig), 0o644); err != nil {+ t.Fatal(err)+ }++ // Add a new ollama-managed model+ newModels := []string{"new-ollama-model"}+ if err := pi.Edit(newModels); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ cfg := readConfig()+ providers := cfg["providers"].(map[string]any)+ ollama := providers["ollama"].(map[string]any)+ modelsArray := ollama["models"].([]any)++ // Should have: new-ollama-model (managed) + 2 user models (preserved)+ if len(modelsArray) != 3 {+ t.Errorf("Expected 3 models (1 new managed + 2 preserved user models), got %d", len(modelsArray))+ }++ modelIDs := make(map[string]map[string]any)+ for _, m := range modelsArray {+ modelObj := m.(map[string]any)+ id := modelObj["id"].(string)+ modelIDs[id] = modelObj+ }++ // Verify new model has _launch marker+ if m, ok := modelIDs["new-ollama-model"]; !ok {+ t.Errorf("new-ollama-model should be present")+ } else if m["_launch"] != true {+ t.Errorf("new-ollama-model should have _launch marker")+ }++ // Verify user models are preserved+ if _, ok := modelIDs["user-model-1"]; !ok {+ t.Errorf("user-model-1 should be preserved")+ }+ if _, ok := modelIDs["user-model-2"]; !ok {+ t.Errorf("user-model-2 should be preserved")+ } else if modelIDs["user-model-2"]["customField"] != "preserved" {+ t.Errorf("user-model-2 customField should be preserved")+ }++ // Verify old ollama-managed model is removed (not in new list)+ if _, ok := modelIDs["ollama-managed"]; ok {+ t.Errorf("ollama-managed should be removed (old ollama model not in new selection)")+ }+ })++ t.Run("updates settings.json with default provider and model", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ // Create existing settings with other fields+ settingsPath := filepath.Join(configDir, "settings.json")+ existingSettings := `{+ "theme": "dark",+ "customSetting": "value",+ "defaultProvider": "anthropic",+ "defaultModel": "claude-3"+ }`+ if err := os.WriteFile(settingsPath, []byte(existingSettings), 0o644); err != nil {+ t.Fatal(err)+ }++ models := []string{"llama3.2"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ data, err := os.ReadFile(settingsPath)+ if err != nil {+ t.Fatalf("Failed to read settings: %v", err)+ }++ var settings map[string]any+ if err := json.Unmarshal(data, &settings); err != nil {+ t.Fatalf("Failed to parse settings: %v", err)+ }++ // Verify defaultProvider is set to ollama+ if settings["defaultProvider"] != "ollama" {+ t.Errorf("defaultProvider = %v, want ollama", settings["defaultProvider"])+ }++ // Verify defaultModel is set to first model+ if settings["defaultModel"] != "llama3.2" {+ t.Errorf("defaultModel = %v, want llama3.2", settings["defaultModel"])+ }++ // Verify other fields are preserved+ if settings["theme"] != "dark" {+ t.Errorf("theme = %v, want dark (preserved)", settings["theme"])+ }+ if settings["customSetting"] != "value" {+ t.Errorf("customSetting = %v, want value (preserved)", settings["customSetting"])+ }+ })++ t.Run("creates settings.json if it does not exist", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ models := []string{"qwen3:8b"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() error = %v", err)+ }++ settingsPath := filepath.Join(configDir, "settings.json")+ data, err := os.ReadFile(settingsPath)+ if err != nil {+ t.Fatalf("settings.json should be created: %v", err)+ }++ var settings map[string]any+ if err := json.Unmarshal(data, &settings); err != nil {+ t.Fatalf("Failed to parse settings: %v", err)+ }++ if settings["defaultProvider"] != "ollama" {+ t.Errorf("defaultProvider = %v, want ollama", settings["defaultProvider"])+ }+ if settings["defaultModel"] != "qwen3:8b" {+ t.Errorf("defaultModel = %v, want qwen3:8b", settings["defaultModel"])+ }+ })++ t.Run("handles corrupt settings.json gracefully", func(t *testing.T) {+ cleanup()+ os.MkdirAll(configDir, 0o755)++ // Create corrupt settings+ settingsPath := filepath.Join(configDir, "settings.json")+ if err := os.WriteFile(settingsPath, []byte("{invalid"), 0o644); err != nil {+ t.Fatal(err)+ }++ models := []string{"test-model"}+ if err := pi.Edit(models); err != nil {+ t.Fatalf("Edit() should not fail with corrupt settings, got %v", err)+ }++ data, err := os.ReadFile(settingsPath)+ if err != nil {+ t.Fatalf("Failed to read settings: %v", err)+ }++ var settings map[string]any+ if err := json.Unmarshal(data, &settings); err != nil {+ t.Fatalf("settings.json should be valid after Edit, got parse error: %v", err)+ }++ if settings["defaultProvider"] != "ollama" {+ t.Errorf("defaultProvider = %v, want ollama", settings["defaultProvider"])+ }+ if settings["defaultModel"] != "test-model" {+ t.Errorf("defaultModel = %v, want test-model", settings["defaultModel"])+ }+ })+}++func TestPiModels(t *testing.T) {+ pi := &Pi{}++ t.Run("returns nil when no config exists", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ models := pi.Models()+ if models != nil {+ t.Errorf("Models() = %v, want nil", models)+ }+ })++ t.Run("returns models from config", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ if err := os.MkdirAll(configDir, 0o755); err != nil {+ t.Fatal(err)+ }+ config := `{+ "providers": {+ "ollama": {+ "models": [+ {"id": "llama3.2"},+ {"id": "qwen3:8b"}+ ]+ }+ }+ }`+ configPath := filepath.Join(configDir, "models.json")+ if err := os.WriteFile(configPath, []byte(config), 0o644); err != nil {+ t.Fatal(err)+ }++ models := pi.Models()+ if len(models) != 2 {+ t.Errorf("Models() returned %d models, want 2", len(models))+ }+ if models[0] != "llama3.2" || models[1] != "qwen3:8b" {+ t.Errorf("Models() = %v, want [llama3.2 qwen3:8b] (sorted)", models)+ }+ })++ t.Run("returns sorted models", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ if err := os.MkdirAll(configDir, 0o755); err != nil {+ t.Fatal(err)+ }+ config := `{+ "providers": {+ "ollama": {+ "models": [+ {"id": "z-model"},+ {"id": "a-model"},+ {"id": "m-model"}+ ]+ }+ }+ }`+ configPath := filepath.Join(configDir, "models.json")+ if err := os.WriteFile(configPath, []byte(config), 0o644); err != nil {+ t.Fatal(err)+ }++ models := pi.Models()+ if models[0] != "a-model" || models[1] != "m-model" || models[2] != "z-model" {+ t.Errorf("Models() = %v, want [a-model m-model z-model] (sorted)", models)+ }+ })++ t.Run("returns nil when models array is missing", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ if err := os.MkdirAll(configDir, 0o755); err != nil {+ t.Fatal(err)+ }+ config := `{+ "providers": {+ "ollama": {}+ }+ }`+ configPath := filepath.Join(configDir, "models.json")+ if err := os.WriteFile(configPath, []byte(config), 0o644); err != nil {+ t.Fatal(err)+ }++ models := pi.Models()+ if models != nil {+ t.Errorf("Models() = %v, want nil when models array is missing", models)+ }+ })++ t.Run("handles corrupt config gracefully", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configDir := filepath.Join(tmpDir, ".pi", "agent")+ if err := os.MkdirAll(configDir, 0o755); err != nil {+ t.Fatal(err)+ }+ configPath := filepath.Join(configDir, "models.json")+ if err := os.WriteFile(configPath, []byte("{invalid json}"), 0o644); err != nil {+ t.Fatal(err)+ }++ models := pi.Models()+ if models != nil {+ t.Errorf("Models() = %v, want nil for corrupt config", models)+ }+ })+}++func TestIsPiOllamaModel(t *testing.T) {+ tests := []struct {+ name string+ cfg map[string]any+ want bool+ }{+ {"with _launch true", map[string]any{"id": "m", "_launch": true}, true},+ {"with _launch false", map[string]any{"id": "m", "_launch": false}, false},+ {"without _launch", map[string]any{"id": "m"}, false},+ {"with _launch non-bool", map[string]any{"id": "m", "_launch": "yes"}, false},+ {"empty map", map[string]any{}, false},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if got := isPiOllamaModel(tt.cfg); got != tt.want {+ t.Errorf("isPiOllamaModel(%v) = %v, want %v", tt.cfg, got, tt.want)+ }+ })+ }+}++func TestCreateConfig(t *testing.T) {+ t.Run("sets vision input when model has vision capability", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":["vision"],"model_info":{}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "llava:7b")++ if cfg["id"] != "llava:7b" {+ t.Errorf("id = %v, want llava:7b", cfg["id"])+ }+ if cfg["_launch"] != true {+ t.Error("expected _launch = true")+ }+ input, ok := cfg["input"].([]string)+ if !ok || len(input) != 2 || input[0] != "text" || input[1] != "image" {+ t.Errorf("input = %v, want [text image]", cfg["input"])+ }+ })++ t.Run("sets text-only input when model lacks vision", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":["completion"],"model_info":{}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "llama3.2")++ input, ok := cfg["input"].([]string)+ if !ok || len(input) != 1 || input[0] != "text" {+ t.Errorf("input = %v, want [text]", cfg["input"])+ }+ if _, ok := cfg["reasoning"]; ok {+ t.Error("reasoning should not be set for non-thinking model")+ }+ })++ t.Run("sets reasoning when model has thinking capability", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":["thinking"],"model_info":{}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "qwq")++ if cfg["reasoning"] != true {+ t.Error("expected reasoning = true for thinking model")+ }+ })++ t.Run("extracts context window from model info", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":[],"model_info":{"llama.context_length":131072}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "llama3.2")++ if cfg["contextWindow"] != 131072 {+ t.Errorf("contextWindow = %v, want 131072", cfg["contextWindow"])+ }+ })++ t.Run("handles all capabilities together", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":["vision","thinking"],"model_info":{"qwen3.context_length":32768}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "qwen3-vision")++ input := cfg["input"].([]string)+ if len(input) != 2 || input[0] != "text" || input[1] != "image" {+ t.Errorf("input = %v, want [text image]", input)+ }+ if cfg["reasoning"] != true {+ t.Error("expected reasoning = true")+ }+ if cfg["contextWindow"] != 32768 {+ t.Errorf("contextWindow = %v, want 32768", cfg["contextWindow"])+ }+ })++ t.Run("returns minimal config when show fails", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.WriteHeader(http.StatusNotFound)+ fmt.Fprintf(w, `{"error":"model not found"}`)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "missing-model")++ if cfg["id"] != "missing-model" {+ t.Errorf("id = %v, want missing-model", cfg["id"])+ }+ if cfg["_launch"] != true {+ t.Error("expected _launch = true")+ }+ // Should not have capability fields+ if _, ok := cfg["input"]; ok {+ t.Error("input should not be set when show fails")+ }+ if _, ok := cfg["reasoning"]; ok {+ t.Error("reasoning should not be set when show fails")+ }+ if _, ok := cfg["contextWindow"]; ok {+ t.Error("contextWindow should not be set when show fails")+ }+ })++ t.Run("skips zero context length", func(t *testing.T) {+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.URL.Path == "/api/show" {+ fmt.Fprintf(w, `{"capabilities":[],"model_info":{"llama.context_length":0}}`)+ return+ }+ w.WriteHeader(http.StatusNotFound)+ }))+ defer srv.Close()++ u, _ := url.Parse(srv.URL)+ client := api.NewClient(u, srv.Client())++ cfg := createConfig(context.Background(), client, "test-model")++ if _, ok := cfg["contextWindow"]; ok {+ t.Error("contextWindow should not be set for zero value")+ }+ })+}++// Ensure Capability constants used in createConfig match expected values+func TestPiCapabilityConstants(t *testing.T) {+ if model.CapabilityVision != "vision" {+ t.Errorf("CapabilityVision = %q, want %q", model.CapabilityVision, "vision")+ }+ if model.CapabilityThinking != "thinking" {+ t.Errorf("CapabilityThinking = %q, want %q", model.CapabilityThinking, "thinking")+ }+}diff --git a/cmd/tui/tui.go b/cmd/tui/tui.goindex 59c983e3d..41e1b630a 100644--- a/cmd/tui/tui.go+++ b/cmd/tui/tui.go@@ -102,6 +102,11 @@ func getOtherIntegrations() []menuItem {description: "Open Open Code integration",integration: "opencode",},+ {+ title: "Launch Pi",+ description: "Open Pi coding agent",+ integration: "pi",+ },}}