OpenAI baseUrl support

cmd/root.go

@@ -2,8 +2,8 @@ package cmd
 
 import (
 	"context"
-	"fmt"
 	"os"
+	"fmt"
 	"sync"
 	"time"
 
@@ -21,8 +21,15 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var (
+	// These are populated by cobra during flag parsing
+	debug bool
+	cwd string
+	prompt string
+	alwaysAllowPermissions bool
+)
 var rootCmd = &cobra.Command{
-	Use:   "opencode",
+	Use: "opencode",
 	Short: "Terminal-based AI assistant for software development",
 	Long: `OpenCode is a powerful terminal-based AI assistant that helps with software development tasks.
 It provides an interactive chat interface with AI capabilities, code analysis, and LSP integration
@@ -46,6 +53,24 @@ to assist developers in writing, debugging, and understanding code directly from
   # Run a single non-interactive prompt with JSON output format
   opencode -p "Explain the use of context in Go" -f json
   `,
+	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+		// Ensure CWD is determined correctly before loading config
+		if cwd == "" {
+			c, err := os.Getwd()
+			if err != nil {
+				return fmt.Errorf("failed to get current working directory: %v", err)
+			}
+			cwd = c
+		}
+		_, err := config.Load(cwd, debug)
+		if err != nil {
+			return fmt.Errorf("failed to load initial configuration: %w", err)
+		}
+		if cmd.Flags().Changed("always-allow-permissions") {
+			config.Get().AlwaysAllowPermissions = alwaysAllowPermissions
+		}
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		// If the help flag is set, show the help message
 		if cmd.Flag("help").Changed {
@@ -58,9 +83,11 @@ to assist developers in writing, debugging, and understanding code directly from
 		}
 
 		// Load the config
-		debug, _ := cmd.Flags().GetBool("debug")
-		cwd, _ := cmd.Flags().GetString("cwd")
-		prompt, _ := cmd.Flags().GetString("prompt")
+		// Config is already loaded by PersistentPreRunE. We can get it directly.
+		cfg := config.Get()
+		if cfg == nil { // Should not happen if PersistentPreRunE ran successfully
+			return fmt.Errorf("configuration not loaded")
+		}
 		outputFormat, _ := cmd.Flags().GetString("output-format")
 		quiet, _ := cmd.Flags().GetBool("quiet")
 
@@ -69,22 +96,12 @@ to assist developers in writing, debugging, and understanding code directly from
 			return fmt.Errorf("invalid format option: %s\n%s", outputFormat, format.GetHelpText())
 		}
 
-		if cwd != "" {
-			err := os.Chdir(cwd)
-			if err != nil {
-				return fmt.Errorf("failed to change directory: %v", err)
-			}
-		}
-		if cwd == "" {
-			c, err := os.Getwd()
+		// CWD logic is now handled in PersistentPreRunE or by direct use of cwd
+		if cwd != cfg.WorkingDir { // Ensure current directory matches config if changed by Chdir
+			err := os.Chdir(cfg.WorkingDir)
 			if err != nil {
-				return fmt.Errorf("failed to get current working directory: %v", err)
+				return fmt.Errorf("failed to change directory to config working dir: %v", err)
 			}
-			cwd = c
-		}
-		_, err := config.Load(cwd, debug)
-		if err != nil {
-			return err
 		}
 
 		// Connect DB, this will also run migrations
@@ -291,9 +308,10 @@ func Execute() {
 func init() {
 	rootCmd.Flags().BoolP("help", "h", false, "Help")
 	rootCmd.Flags().BoolP("version", "v", false, "Version")
-	rootCmd.Flags().BoolP("debug", "d", false, "Debug")
-	rootCmd.Flags().StringP("cwd", "c", "", "Current working directory")
-	rootCmd.Flags().StringP("prompt", "p", "", "Prompt to run in non-interactive mode")
+	rootCmd.PersistentFlags().BoolVarP(&debug, "debug", "d", false, "Debug")
+	rootCmd.PersistentFlags().StringVarP(&cwd, "cwd", "c", "", "Current working directory")
+	rootCmd.PersistentFlags().StringVarP(&prompt, "prompt", "p", "", "Prompt to run in non-interactive mode")
+	rootCmd.PersistentFlags().BoolVarP(&alwaysAllowPermissions, "always-allow-permissions", "A", false, "Globally allow all permissions without prompting for the current and future sessions")
 
 	// Add format flag with validation logic
 	rootCmd.Flags().StringP("output-format", "f", format.Text.String(),

internal/config/config.go

@@ -83,16 +83,17 @@ type ShellConfig struct {
 type Config struct {
 	Data         Data                              `json:"data"`
 	WorkingDir   string                            `json:"wd,omitempty"`
-	MCPServers   map[string]MCPServer              `json:"mcpServers,omitempty"`
+	MCPServers map[string]MCPServer `json:"mcpServers,omitempty"`
 	Providers    map[models.ModelProvider]Provider `json:"providers,omitempty"`
 	LSP          map[string]LSPConfig              `json:"lsp,omitempty"`
 	Agents       map[AgentName]Agent               `json:"agents,omitempty"`
 	Debug        bool                              `json:"debug,omitempty"`
 	DebugLSP     bool                              `json:"debugLSP,omitempty"`
 	ContextPaths []string                          `json:"contextPaths,omitempty"`
-	TUI          TUIConfig                         `json:"tui"`
-	Shell        ShellConfig                       `json:"shell,omitempty"`
-	AutoCompact  bool                              `json:"autoCompact,omitempty"`
+	TUI TUIConfig `json:"tui"`
+	Shell ShellConfig `json:"shell,omitempty"`
+	AutoCompact           bool `json:"autoCompact,omitempty"`
+	AlwaysAllowPermissions bool `json:"alwaysAllowPermissions,omitempty"` // New field
 }
 
 // Application constants
@@ -221,8 +222,9 @@ func configureViper() {
 func setDefaults(debug bool) {
 	viper.SetDefault("data.directory", defaultDataDirectory)
 	viper.SetDefault("contextPaths", defaultContextPaths)
-	viper.SetDefault("tui.theme", "opencode")
+	viper.SetDefault("tui.theme", "opencode") 
 	viper.SetDefault("autoCompact", true)
+	viper.SetDefault("alwaysAllowPermissions", false) // New default
 
 	// Set default shell from environment or fallback to /bin/bash
 	shellPath := os.Getenv("SHELL")
@@ -629,6 +631,44 @@ func getProviderAPIKey(provider models.ModelProvider) string {
 	return ""
 }
 
+
+// GetOpenAIBaseURL gets the base URL override for OpenAI-compatible providers
+func GetOpenAIBaseURL() string {
+    return os.Getenv("OPENAI_BASE_URL")
+}
+
+// GetOpenAIModelOverride gets the model name override for OpenAI-compatible providers
+func GetOpenAIModelOverride() string {
+    return os.Getenv("OPENAI_MODEL_OVERRIDE")
+}
+
+// GetOpenAIReasoningEffort gets the reasoning effort level
+func GetOpenAIReasoningEffort() string {
+    effort := os.Getenv("OPENAI_REASONING_EFFORT")
+    if effort == "" {
+        return "medium" // default
+    }
+    return effort
+}
+
+// GetOpenAIExtraHeaders parses extra headers from environment
+func GetOpenAIExtraHeaders() map[string]string {
+    headersStr := os.Getenv("OPENAI_EXTRA_HEADERS")
+    if headersStr == "" {
+        return nil
+    }
+
+    headers := make(map[string]string)
+    pairs := strings.Split(headersStr, ",")
+    for _, pair := range pairs {
+        kv := strings.SplitN(strings.TrimSpace(pair), "=", 2)
+        if len(kv) == 2 {
+            headers[kv[0]] = kv[1]
+        }
+    }
+    return headers
+}
+
 // setDefaultModelForAgent sets a default model for an agent based on available providers
 func setDefaultModelForAgent(agent AgentName) bool {
 	// Check providers in order of preference
@@ -874,7 +914,22 @@ func UpdateTheme(themeName string) error {
 	cfg.TUI.Theme = themeName
 
 	// Update the file config
-	return updateCfgFile(func(config *Config) {
-		config.TUI.Theme = themeName
+	return updateCfgFile(func(userCfg *Config) {
+		userCfg.TUI.Theme = themeName
+	})
+}
+
+// UpdateAlwaysAllowPermissions updates the alwaysAllowPermissions setting in the configuration and writes it to the config file.
+func UpdateAlwaysAllowPermissions(value bool) error {
+	if cfg == nil {
+		return fmt.Errorf("config not loaded")
+	}
+
+	// Update the in-memory config
+	cfg.AlwaysAllowPermissions = value
+
+	// Update the file config
+	return updateCfgFile(func(userCfg *Config) { // Match existing pattern in updateCfgFile
+		userCfg.AlwaysAllowPermissions = value
 	})
 }

internal/llm/agent/agent.go

@@ -688,55 +688,57 @@ func (a *agent) Summarize(ctx context.Context, sessionID string) error {
 }
 
 func createAgentProvider(agentName config.AgentName) (provider.Provider, error) {
-	cfg := config.Get()
-	agentConfig, ok := cfg.Agents[agentName]
-	if !ok {
-		return nil, fmt.Errorf("agent %s not found", agentName)
-	}
-	model, ok := models.SupportedModels[agentConfig.Model]
-	if !ok {
-		return nil, fmt.Errorf("model %s not supported", agentConfig.Model)
-	}
-
-	providerCfg, ok := cfg.Providers[model.Provider]
-	if !ok {
-		return nil, fmt.Errorf("provider %s not supported", model.Provider)
-	}
-	if providerCfg.Disabled {
-		return nil, fmt.Errorf("provider %s is not enabled", model.Provider)
-	}
-	maxTokens := model.DefaultMaxTokens
-	if agentConfig.MaxTokens > 0 {
-		maxTokens = agentConfig.MaxTokens
-	}
-	opts := []provider.ProviderClientOption{
-		provider.WithAPIKey(providerCfg.APIKey),
-		provider.WithModel(model),
-		provider.WithSystemMessage(prompt.GetAgentPrompt(agentName, model.Provider)),
-		provider.WithMaxTokens(maxTokens),
-	}
-	if model.Provider == models.ProviderOpenAI || model.Provider == models.ProviderLocal && model.CanReason {
-		opts = append(
-			opts,
-			provider.WithOpenAIOptions(
-				provider.WithReasoningEffort(agentConfig.ReasoningEffort),
-			),
-		)
-	} else if model.Provider == models.ProviderAnthropic && model.CanReason && agentName == config.AgentCoder {
-		opts = append(
-			opts,
-			provider.WithAnthropicOptions(
-				provider.WithAnthropicShouldThinkFn(provider.DefaultShouldThinkFn),
-			),
-		)
-	}
-	agentProvider, err := provider.NewProvider(
-		model.Provider,
-		opts...,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("could not create provider: %v", err)
-	}
-
-	return agentProvider, nil
+    cfg := config.Get()
+    agentConfig, ok := cfg.Agents[agentName]
+    if !ok {
+        return nil, fmt.Errorf("agent %s not found", agentName)
+    }
+    model, ok := models.SupportedModels[agentConfig.Model]
+    if !ok {
+        return nil, fmt.Errorf("model %s not supported", agentConfig.Model)
+    }
+    providerCfg, ok := cfg.Providers[model.Provider]
+    if !ok {
+        return nil, fmt.Errorf("provider %s not supported", model.Provider)
+    }
+    if providerCfg.Disabled {
+        return nil, fmt.Errorf("provider %s is not enabled", model.Provider)
+    }
+    maxTokens := model.DefaultMaxTokens
+    if agentConfig.MaxTokens > 0 {
+        maxTokens = agentConfig.MaxTokens
+    }
+    opts := []provider.ProviderClientOption{
+        provider.WithAPIKey(providerCfg.APIKey),
+        provider.WithModel(model),
+        provider.WithSystemMessage(prompt.GetAgentPrompt(agentName, model.Provider)),
+        provider.WithMaxTokens(maxTokens),
+    }
+
+    // Handle OpenAI and OpenAI-compatible providers
+    if model.Provider == models.ProviderOpenAI || model.Provider == models.ProviderLocal && model.CanReason {
+        opts = append(
+            opts,
+            provider.WithOpenAIOptions(
+                provider.WithReasoningEffort(agentConfig.ReasoningEffort),
+            ),
+        )
+    } else if model.Provider == models.ProviderAnthropic && model.CanReason && agentName == config.AgentCoder {
+        opts = append(
+            opts,
+            provider.WithAnthropicOptions(
+                provider.WithAnthropicShouldThinkFn(provider.DefaultShouldThinkFn),
+            ),
+        )
+    }
+
+    agentProvider, err := provider.NewProvider(
+        model.Provider,
+        opts...,
+    )
+    if err != nil {
+        return nil, fmt.Errorf("could not create provider: %v", err)
+    }
+
+    return agentProvider, nil
 }

internal/llm/models/gemini.go

@@ -15,9 +15,9 @@ var GeminiModels = map[ModelID]Model{
 		ID:                  Gemini25Flash,
 		Name:                "Gemini 2.5 Flash",
 		Provider:            ProviderGemini,
-		APIModel:            "gemini-2.5-flash-preview-04-17",
+		APIModel:            "gemini-2.5-flash-preview-05-20",
 		CostPer1MIn:         0.15,
-		CostPer1MInCached:   0,
+		CostPer1MInCached:   0.0375,
 		CostPer1MOutCached:  0,
 		CostPer1MOut:        0.60,
 		ContextWindow:       1000000,
@@ -28,9 +28,9 @@ var GeminiModels = map[ModelID]Model{
 		ID:                  Gemini25,
 		Name:                "Gemini 2.5 Pro",
 		Provider:            ProviderGemini,
-		APIModel:            "gemini-2.5-pro-preview-05-06",
+		APIModel:            "gemini-2.5-pro-preview-06-05",
 		CostPer1MIn:         1.25,
-		CostPer1MInCached:   0,
+		CostPer1MInCached:   0.31,
 		CostPer1MOutCached:  0,
 		CostPer1MOut:        10,
 		ContextWindow:       1000000,

internal/llm/models/vertexai.go

@@ -13,7 +13,7 @@ var VertexAIGeminiModels = map[ModelID]Model{
 		ID:                  VertexAIGemini25Flash,
 		Name:                "VertexAI: Gemini 2.5 Flash",
 		Provider:            ProviderVertexAI,
-		APIModel:            "gemini-2.5-flash-preview-04-17",
+		APIModel:            "gemini-2.5-flash-preview-05-20",
 		CostPer1MIn:         GeminiModels[Gemini25Flash].CostPer1MIn,
 		CostPer1MInCached:   GeminiModels[Gemini25Flash].CostPer1MInCached,
 		CostPer1MOut:        GeminiModels[Gemini25Flash].CostPer1MOut,

internal/permission/permission.go

@@ -72,6 +72,12 @@ func (s *permissionService) Deny(permission PermissionRequest) {
 }
 
 func (s *permissionService) Request(opts CreatePermissionRequest) bool {
+	// Check global "always allow" setting first
+	globalCfg := config.Get()
+	if globalCfg != nil && globalCfg.AlwaysAllowPermissions {
+		return true
+	}
+
 	if slices.Contains(s.autoApproveSessions, opts.SessionID) {
 		return true
 	}

internal/tui/bindings/bindings.go

@@ -0,0 +1,20 @@
+package bindings
+
+import "github.com/charmbracelet/bubbles/key"
+
+type Bindings interface {
+	BindingKeys() []key.Binding
+}
+
+func KeyMapToSlice(km any) []key.Binding {
+	switch km := km.(type) {
+	case map[string]key.Binding:
+		bindings := make([]key.Binding, 0, len(km))
+		for _, v := range km {
+			bindings = append(bindings, v)
+		}
+		return bindings
+	default:
+		return nil
+	}
+}