kward 0.78.0 → 0.80.0

data/lib/kward/cli/auth_commands.rb

@@ -22,12 +22,15 @@ module Kward
 
       # Writes the auth status output for the terminal CLI flow.
       def print_auth_status
-        config = safely_read_config.to_h
+        store = api_key_store
+        store.migrate_openrouter_config_key!
         lines = ["#{colored("Auth Status", :green, :bold)}", ""]
         lines << auth_status_line("OpenAI OAuth", File.exist?(OpenAIOAuth.default_auth_path), OpenAIOAuth.default_auth_path)
         lines << auth_status_line("Anthropic OAuth", File.exist?(AnthropicOAuth.default_auth_path), AnthropicOAuth.default_auth_path)
         lines << auth_status_line("GitHub OAuth", File.exist?(GithubOAuth.default_auth_path), GithubOAuth.default_auth_path)
-        lines << auth_status_line("OpenRouter API key", !config["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?, ConfigFiles.config_path)
+        ProviderCatalog.api_key_providers.each do |provider|
+          lines << auth_status_line("#{provider.name} API key", store.configured?(provider.id), store.path)
+        end
         @prompt.say lines.join("\n")
       end
 
@@ -45,7 +48,11 @@ module Kward
           File.delete(path)
           removed << path
         end
-        removed << "OpenRouter API key" if OpenRouterAPIKey.new.logout
+        store = api_key_store
+        store.migrate_openrouter_config_key!
+        ProviderCatalog.api_key_providers.each do |provider|
+          removed << "#{provider.name} API key" if store.delete(provider.id)
+        end
 
         if removed.empty?
           @prompt.say "No saved credentials found."
@@ -54,29 +61,81 @@ module Kward
         end
       end
 
-      def login(provider: nil, oauth: nil)
-        provider = provider.to_s.downcase
-        if provider == "openrouter"
-          auth = oauth || OpenRouterAPIKey.new
-          path = auth.login(prompt: @prompt)
-          @prompt.say("#{colored("Saved", :green, :bold)} OpenRouter API key to #{path}")
+      def login(provider: nil, oauth: nil, auth_method: nil)
+        provider = normalized_login_provider(provider)
+        if api_key_login?(provider, auth_method)
+          login_with_api_key(provider)
           return
         end
 
         oauth ||= case provider
-                  when "github" then GithubOAuth.new
-                  when "anthropic", "claude" then AnthropicOAuth.new
+                  when "github", "copilot" then GithubOAuth.new
+                  when "anthropic" then AnthropicOAuth.new
                   else OpenAIOAuth.new
                   end
         path = oauth.login(prompt: @prompt)
         name = case provider
-               when "github" then "GitHub"
-               when "anthropic", "claude" then "Anthropic"
+               when "github", "copilot" then "GitHub"
+               when "anthropic" then "Anthropic"
                else "OpenAI"
                end
         @prompt.say("#{colored("Saved", :green, :bold)} #{name} OAuth login to #{path}")
       end
 
+      private
+
+      def api_key_store
+        @api_key_store ||= APIKeyStore.new
+      end
+
+      def normalized_login_provider(provider)
+        value = provider.to_s.downcase
+        return "openai" if value.empty?
+        return "anthropic" if ["anthropic", "claude"].include?(value)
+        return "copilot" if ["github", "copilot"].include?(value)
+
+        ProviderCatalog.fetch(value).id
+      end
+
+      def api_key_login?(provider, auth_method)
+        return true if auth_method == :api_key || auth_method == "api_key"
+
+        ProviderCatalog.fetch(provider).api_key? && !["openai", "anthropic", "copilot"].include?(provider)
+      end
+
+      def login_with_api_key(provider_id)
+        provider = ProviderCatalog.fetch(provider_id)
+        raise "#{provider.name} does not accept an API key" unless provider.api_key?
+
+        api_key = @prompt.ask("#{provider.name} API key:").to_s.strip
+        provider_config = provider_config_after_api_key_login(provider)
+        models = refresh_provider_models(provider, api_key)
+        path = api_key_store.store(provider.id, api_key)
+        ConfigFiles.update_config(provider_config) unless provider_config.empty?
+        @prompt.say("#{colored("Saved", :green, :bold)} #{provider.name} API key to #{path}")
+        @prompt.say("Loaded #{models.length} #{provider.name} model#{models.length == 1 ? "" : "s"}.") if models
+      end
+
+      def refresh_provider_models(provider, api_key)
+        return unless ProviderCatalog.runtime(provider.id).automatic_model_discovery?
+
+        model_catalog(provider_id: provider.id, api_key: api_key).refresh
+      end
+
+      def model_catalog(provider_id:, api_key:)
+        ModelCatalog.new(provider_id: provider_id, api_key: api_key)
+      end
+
+      def provider_config_after_api_key_login(provider)
+        return {} unless provider.id == "azure_openai"
+
+        AzureOpenAIConfig.new(
+          endpoint: @prompt.ask("Azure OpenAI endpoint:"),
+          deployment: @prompt.ask("Azure OpenAI deployment name:"),
+          api_version: @prompt.ask("Azure OpenAI API version:")
+        ).to_config
+      end
+
     end
   end
 end

data/lib/kward/cli/commands.rb

@@ -59,6 +59,7 @@ module Kward
             #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
             #{command.call("kward pan")}                          Start Pan mode web UI
             #{command.call("kward rpc")}                          Start the JSON-RPC backend
+            #{command.call("kward transport")}                    Manage transport plugins
 
           #{heading.call("Commands")}
             #{command.call("help")}                               Show this help
@@ -74,6 +75,7 @@ module Kward
             #{command.call("openrouter refresh|list")}             Refresh or list cached OpenRouter models
             #{command.call("pan")}                                Start Pan mode web UI
             #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
+            #{command.call("transport list|status|run")}            Manage transport plugins
 
           #{heading.call("Options")}
             #{option.call("--working-directory=PATH")}             Run Kward from PATH
@@ -163,6 +165,11 @@ module Kward
             usage: "kward rpc",
             description: "Start the JSON-RPC backend for trusted local UI clients.",
             examples: ["kward rpc", "kward --working-directory ~/code/project rpc"]
+          },
+          "transport" => {
+            usage: "kward transport list|status [NAME]|run NAME [WORKSPACE]",
+            description: "Inspect or run trusted external transport plugins.",
+            examples: ["kward transport list", "kward transport status", "kward transport run telegram", "kward transport run telegram ~/code/project"]
           }
         }
       end

data/lib/kward/cli/doctor.rb

@@ -25,6 +25,7 @@ module Kward
           doctor_directory_check("Session directory", SessionStore.new(cwd: current_workspace_root).session_dir, create: true),
           doctor_workspace_check,
           doctor_model_check,
+          doctor_local_endpoint_check(config),
           doctor_auth_check(config),
           doctor_pan_check(config_result),
           { status: :ok, label: "Color", message: @color_enabled ? "enabled" : "disabled" }
@@ -89,14 +90,34 @@ module Kward
         { status: :warning, label: "Model", message: e.message }
       end
 
+      def doctor_local_endpoint_check(config)
+        provider = ENV["KWARD_PROVIDER"].to_s.strip
+        provider = config["provider"].to_s.strip if provider.empty?
+        return { status: :ok, label: "Local endpoint", message: "not selected" } unless provider.casecmp?("local")
+
+        backend = ENV["KWARD_LOCAL_BACKEND"].to_s.strip
+        backend = config["local_backend"].to_s.strip if backend.empty?
+        defaults = Kward::Client::LOCAL_BASE_URLS
+        url = ENV["KWARD_LOCAL_BASE_URL"].to_s.strip
+        url = config["local_base_url"].to_s.strip if url.empty?
+        url = defaults.fetch(backend.empty? ? "ollama" : backend, defaults.fetch("ollama")) if url.empty?
+        uri = URI.parse(url)
+        loopback = ["127.0.0.1", "::1", "localhost"].include?(uri.host)
+        { status: loopback ? :ok : :warning, label: "Local endpoint", message: "#{url}#{loopback ? " (loopback)" : " (non-loopback)"}" }
+      rescue URI::InvalidURIError
+        { status: :error, label: "Local endpoint", message: "invalid URL: #{url}" }
+      end
+
       def doctor_auth_check(config)
         openai_auth = OpenAIOAuth.default_auth_path
         github_auth = GithubOAuth.default_auth_path
         has_openrouter = !config.to_h["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?
+        local_provider = @client.respond_to?(:current_provider) && @client.current_provider == "Local"
         paths = []
         paths << "OpenAI OAuth" if File.exist?(openai_auth)
         paths << "GitHub OAuth" if File.exist?(github_auth)
         paths << "OpenRouter API key" if has_openrouter
+        paths << "Local endpoint (no authentication required)" if local_provider
         return { status: :ok, label: "Auth", message: paths.join(", ") } if paths.any?
 
         { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }

data/lib/kward/cli/git.rb

@@ -1,4 +1,5 @@
 require "open3"
+require "pathname"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -131,20 +132,40 @@ module Kward
         { path: path, staged: status[0] != " " && status[0] != "?", untracked: status == "??" }
       end
 
-      def git_commit(root, message)
-        before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
-        return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+      def git_commit_for_agent(root, message:, paths: nil)
+        git_commit(root, message, paths: paths, stage_all: true, run_hooks: false)
+      end
+
+      def git_commit(root, message, paths: nil, stage_all: false, run_hooks: true)
+        if run_hooks
+          before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
+          return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+        end
 
-        return git_commit_staged(root, message) if git_staged_changes?(root)
+        return git_commit_staged(root, message, run_hooks: run_hooks) if !stage_all && paths.nil? && git_staged_changes?(root)
 
-        add_output, add_status = Open3.capture2e("git", "add", "--all", chdir: root.to_s)
+        add_arguments = ["git", "add", "--all"]
+        add_arguments.concat(["--", *validated_git_commit_paths(root, paths)]) if paths
+        add_output, add_status = Open3.capture2e(*add_arguments, chdir: root.to_s)
         return { success: false, output: add_output } unless add_status.success?
 
-        git_commit_staged(root, message)
+        git_commit_staged(root, message, run_hooks: run_hooks)
       rescue StandardError => e
         { success: false, output: e.message }
       end
 
+      def validated_git_commit_paths(root, paths)
+        Array(paths).map do |path|
+          value = path.to_s
+          expanded = File.expand_path(value, root.to_s)
+          unless !value.empty? && !Pathname.new(value).absolute? && (expanded == root.to_s || expanded.start_with?("#{root}/"))
+            raise ArgumentError, "Git commit path must be workspace-relative: #{value}"
+          end
+
+          value
+        end
+      end
+
       def git_staged_changes?(root)
         _output, status = Open3.capture2e("git", "diff", "--cached", "--quiet", chdir: root.to_s)
         !status.success?
@@ -152,10 +173,12 @@ module Kward
         false
       end
 
-      def git_commit_staged(root, message)
+      def git_commit_staged(root, message, run_hooks: true)
         commit_output, commit_status = Open3.capture2e("git", "commit", "-m", message.to_s, chdir: root.to_s)
         result = { success: commit_status.success?, output: commit_output }
-        git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        if run_hooks
+          git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        end
         result
       rescue StandardError => e
         { success: false, output: e.message }

data/lib/kward/cli/plugins.rb

@@ -31,6 +31,7 @@ module Kward
       end
 
       def reload_plugins(conversation)
+        @prompt_templates = nil
         @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
         @prompt.update_slash_commands(slash_command_entries) if @prompt.respond_to?(:update_slash_commands)
         conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)

data/lib/kward/cli/prompt_interface.rb

@@ -27,6 +27,7 @@ module Kward
           banner_message: Kward::PromptInterface::BANNER_MESSAGE,
           tab_keybindings: ConfigFiles.composer_tab_keybindings,
           prompt_history: PromptHistory.new(cwd: current_workspace_root),
+          workspace_root: current_workspace_root,
           editor_mode: ConfigFiles.editor_mode,
           editor_mode_source: -> { ConfigFiles.editor_mode },
           editor_auto_indent: ConfigFiles.editor_auto_indent?,
@@ -67,6 +68,12 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def update_prompt_workspace_root(root)
+        return unless @prompt.respond_to?(:update_workspace_root)
+
+        @prompt.update_workspace_root(root, prompt_history: PromptHistory.new(cwd: root))
+      end
+
       # Writes the startup info screen output for the terminal CLI flow.
       def print_visual_banner
         return unless @prompt.respond_to?(:print_visual_banner)

data/lib/kward/cli/rendering.rb

@@ -272,8 +272,12 @@ module Kward
       # Writes the block delta output for the terminal CLI flow.
       def print_block_delta(label, delta)
         if prompt_interface?
-          @prompt.start_stream_block(label)
-          @prompt.write_delta(delta)
+          if @prompt.respond_to?(:write_stream_block)
+            @prompt.write_stream_block(label, delta, finish: false)
+          else
+            @prompt.start_stream_block(label)
+            @prompt.write_delta(delta)
+          end
         else
           start_stream_block(label)
           print delta

data/lib/kward/cli/runtime_helpers.rb

@@ -317,8 +317,8 @@ module Kward
         @pending_inputs&.first.is_a?(Hash) && @pending_inputs.first[:tab_action]
       end
 
-      def configured_workspace(root: current_workspace_root)
-        Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
+      def configured_workspace(root: current_workspace_root, strict: false)
+        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h, strict: strict)
       end
 
       def workspace_guardrails_enabled?
@@ -401,6 +401,8 @@ module Kward
       end
 
       def current_workspace_root
+        conversation = active_tab&.agent&.conversation if respond_to?(:active_tab, true)
+        return conversation.workspace_root if conversation&.respond_to?(:workspace_root)
         return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
         return @working_directory if @working_directory
 

data/lib/kward/cli/sessions.rb

@@ -103,7 +103,7 @@ module Kward
         @active_session = track_session(session_store.create)
         reset_session_diff
         cleanup_replaced_session(previous_session)
-        conversation = new_conversation(workspace_root: session_store.cwd)
+        conversation = new_conversation(workspace_root: current_workspace_root)
         @active_session.attach(conversation)
         run_lifecycle_hook("session_create", conversation: conversation, payload: { action: "create" })
         update_assistant_prompt(conversation)

data/lib/kward/cli/settings.rb

@@ -88,7 +88,7 @@ module Kward
       def configure_model_settings(conversation)
         initial_index = 0
         loop do
-          selected, selected_index = select_settings_menu_item("Model & Reasoning", ["Provider", "Default model", "Reasoning effort", "Back"], initial_index)
+          selected, selected_index = select_settings_menu_item("Model & Reasoning", ["Provider", "Default model", "Local server preset", "Reasoning effort", "Back"], initial_index)
           break unless selected
 
           initial_index = selected_index if selected_index
@@ -97,6 +97,8 @@ module Kward
             configure_provider(conversation)
           when /\Adefault model/
             configure_model(conversation)
+          when /\Alocal server preset/
+            configure_local_server_preset(conversation)
           when /\Areasoning effort/
             configure_reasoning(conversation)
           else
@@ -118,7 +120,10 @@ module Kward
 
       def provider_choices
         current = current_model_provider
-        ["Codex", "Anthropic", "OpenRouter", "Copilot"].map do |provider|
+        configured_api_key_providers = ProviderCatalog.api_key_providers.filter_map do |provider|
+          provider.name if api_key_store.configured?(provider.id)
+        end
+        (["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"] + configured_api_key_providers).uniq.map do |provider|
           label = provider.dup
           label += " (current)" if provider == current
           label
@@ -131,8 +136,37 @@ module Kward
         return "Anthropic" if text.start_with?("anthropic") || text.start_with?("claude")
         return "OpenRouter" if text.start_with?("openrouter")
         return "Copilot" if text.start_with?("copilot")
+        return "Local" if text.start_with?("local")
 
-        nil
+        ProviderCatalog.find_by_name(selected)&.name
+      end
+
+      def configure_local_server_preset(conversation)
+        choices = [
+          "Ollama (http://127.0.0.1:11434/v1)",
+          "LM Studio (http://127.0.0.1:1234/v1)",
+          "llama.cpp (http://127.0.0.1:8080/v1)",
+          "Custom endpoint (edit config)",
+          "Back"
+        ]
+        selected = @prompt.select("Local server preset", choices, title: "Settings")
+        return unless selected
+
+        backend, url = case selected.to_s
+                       when /\AOllama/ then ["ollama", "http://127.0.0.1:11434/v1"]
+                       when /\ALM Studio/ then ["lm_studio", "http://127.0.0.1:1234/v1"]
+                       when /\Allama\.cpp/ then ["llama_cpp", "http://127.0.0.1:8080/v1"]
+                       when /\ACustom endpoint/
+                         runtime_output("Set local_base_url in #{ConfigFiles.config_path}.")
+                         return
+                       else
+                         return
+                       end
+
+        ConfigFiles.update_config("local_backend" => backend, "local_base_url" => url)
+        reload_client_config
+        refresh_conversation_runtime(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
       end
 
       def configure_account_settings
@@ -524,6 +558,10 @@ module Kward
           case selected.to_s.downcase
           when /\Adefault persona/
             configure_default_persona(conversation)
+          when /\Aenable global principles/, /\Adisable global principles/
+            toggle_global_principles(conversation)
+          when /\Aglobal principles \(ignored/
+            runtime_output("Global principles are ignored while a replacement system prompt is configured.")
           when /\Aactive instructions/
             show_active_instructions_summary(conversation)
           else
@@ -533,13 +571,31 @@ module Kward
       end
 
       def personalization_setting_choices(conversation)
+        config = safely_read_config.to_h
+        replacement = ConfigFiles.system_prompt_file_path(config)
+        principles = if replacement
+                       "Global principles (ignored by replacement)"
+                     elsif ConfigFiles.include_config_principles?(config)
+                       "Disable global principles"
+                     else
+                       "Enable global principles"
+                     end
         [
           "Default persona (#{default_persona_label})",
+          principles,
           "Active instructions summary",
           "Back"
         ]
       end
 
+      def toggle_global_principles(conversation)
+        config = safely_read_config.to_h
+        settings = config["system_prompt"].is_a?(Hash) ? config["system_prompt"] : {}
+        ConfigFiles.update_config("system_prompt" => settings.merge("include_principles" => !ConfigFiles.include_config_principles?(config)))
+        conversation&.refresh_system_message!
+        @prompt.redraw if @prompt.respond_to?(:redraw)
+      end
+
       def default_persona_label
         personas = safely_read_config.to_h["personas"]
         value = personas.is_a?(Hash) ? personas["default"] : nil
@@ -569,9 +625,18 @@ module Kward
 
       def show_active_instructions_summary(conversation)
         label = ConfigFiles.active_persona_label(workspace_root: current_workspace_root, model: current_model_id, config: safely_read_config.to_h)
+        config = safely_read_config.to_h
+        replacement_path = ConfigFiles.system_prompt_file_path(config)
         lines = ["Active persona: #{label || "none"}"]
-        lines << "Global PRINCIPLES.md: #{ConfigFiles.agents_prompt ? "present" : "absent"}"
-        lines << "Workspace AGENTS.md: #{ConfigFiles.workspace_agents_prompt(current_workspace_root) ? "present" : "absent"}"
+        if replacement_path
+          lines << "System prompt: replacement (#{replacement_path})"
+          lines << "Global PRINCIPLES.md: ignored by replacement"
+          lines << "Workspace AGENTS.md: ignored by replacement"
+        else
+          lines << "System prompt: Kward default"
+          lines << "Global PRINCIPLES.md: #{ConfigFiles.include_config_principles?(config) ? (ConfigFiles.agents_prompt ? "present" : "absent") : "disabled"}"
+          lines << "Workspace AGENTS.md: #{ConfigFiles.workspace_agents_prompt(current_workspace_root) ? "present" : "absent"}"
+        end
         lines << "Messages: #{conversation.messages.length}" if conversation&.respond_to?(:messages)
         runtime_output(lines.join("\n"))
       end
@@ -659,12 +724,15 @@ module Kward
           return
         end
 
-        selected = @prompt.select("OAuth provider", login_provider_choices, title: "Login")
+        method = selected_login_method(@prompt.select("How would you like to connect?", login_method_choices, title: "Login"))
+        return unless method
+
+        selected = @prompt.select(login_provider_prompt(method), login_provider_choices(method), title: "Login")
         provider = selected_login_provider(selected)
         return unless provider
 
         run_busy_local_command_and_requeue(activity: "running") do
-          login(provider: provider)
+          login(provider: provider, auth_method: method)
           reload_client_config
         end
       rescue StandardError => e
@@ -678,17 +746,40 @@ module Kward
         end
 
         models ||= normalized_available_models(conversation)
-        choices = model_choices(models, conversation)
-        selected = @prompt.select("Default model", choices, title: "Models", custom: true)
-        return unless selected
-
-        provider, model = selected_model(selected, models)
-        raise "Model must be a non-empty string" if model.to_s.strip.empty?
-
-        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
-        reload_client_config
-        refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        provider_filter = nil
+        show_all = false
+        loop do
+          visible_models = provider_filter ? models.select { |model| model[:provider] == provider_filter } : models
+          visible_models = visible_models.select { |model| default_selectable_model?(model) } unless show_all
+          actions = ["Refresh model list", "Enter model ID manually", "Show all models", "Change provider"]
+          selected = @prompt.select("Default model", model_choices(visible_models, conversation) + actions, title: "Models", custom: true)
+          return unless selected
+
+          case selected.to_s
+          when "Refresh model list"
+            refreshed = @client.refresh_available_models(provider: provider_filter) if @client.respond_to?(:refresh_available_models)
+            models = normalized_available_models(conversation, models: refreshed)
+          when "Enter model ID manually"
+            provider = provider_filter || conversation&.provider || current_model_provider
+            model = @prompt.select("Model ID for #{provider}", [], title: "Models", custom: true)
+            return unless model
+            persist_model_selection(provider, model, conversation)
+            return
+          when "Show all models"
+            provider_filter = nil
+            show_all = true
+          when "Change provider"
+            selected_provider_name = selected_provider(@prompt.select("Provider", provider_choices, title: "Models"))
+            if selected_provider_name
+              provider_filter = selected_provider_name
+              show_all = false
+            end
+          else
+            provider, model = selected_model(selected, models)
+            persist_model_selection(provider, model, conversation)
+            return
+          end
+        end
       rescue StandardError => e
         runtime_output("Model error: #{e.message}")
       end
@@ -722,23 +813,38 @@ module Kward
         @prompt.respond_to?(:select)
       end
 
-      def login_provider_choices
-        ["OpenAI", "Anthropic", "OpenRouter", "GitHub"]
+      def login_method_choices
+        ["API key", "Subscription / OAuth"]
       end
 
-      def selected_login_provider(selected)
+      def selected_login_method(selected)
         case selected.to_s.downcase
-        when /\Aopenai\b/
-          "openai"
-        when /\Aanthropic\b/, /\Aclaude\b/
-          "anthropic"
-        when /\Aopenrouter\b/
-          "openrouter"
-        when /\Agithub\b/
-          "github"
+        when /\Aapi key\z/ then :api_key
+        when /\Asubscription \/ oauth\z/ then :oauth
         end
       end
 
+      def login_provider_prompt(method)
+        method == :api_key ? "Add an API key" : "Sign in with a subscription"
+      end
+
+      def login_provider_choices(method)
+        if method == :api_key
+          ProviderCatalog.api_key_providers.map(&:name)
+        else
+          ["Anthropic Claude", "ChatGPT", "GitHub Copilot"]
+        end
+      end
+
+      def selected_login_provider(selected)
+        value = selected.to_s.downcase
+        return "openai" if value == "openai" || value == "chatgpt"
+        return "anthropic" if value == "anthropic" || value == "anthropic claude"
+        return "copilot" if value == "github copilot"
+
+        ProviderCatalog.find_by_name(selected)&.id
+      end
+
       def model_overlay_available?
         @prompt.respond_to?(:select)
       end
@@ -760,11 +866,11 @@ module Kward
         values.find { |value| choice.to_s.downcase.start_with?(value) }
       end
 
-      def normalized_available_models(conversation = current_footer_conversation)
+      def normalized_available_models(conversation = current_footer_conversation, models: nil)
         current_provider = conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
         current_model = conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : nil)
         current_reasoning = conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : nil)
-        models = @client.respond_to?(:available_models) ? @client.available_models : []
+        models ||= @client.respond_to?(:available_models) ? @client.available_models : []
         ModelInfo.normalize_available(
           models,
           current_provider: current_provider,
@@ -784,17 +890,37 @@ module Kward
         choices.empty? ? ["#{current_provider} #{current_model} (current)"] : choices.uniq
       end
 
+      def default_selectable_model?(model)
+        return true if model[:current]
+
+        capabilities = Array(model[:supportedParameters]).map { |value| value.to_s.downcase }
+        return true if capabilities.empty?
+
+        capabilities.any? do |capability|
+          ["tools", "toolchoice", "functioncalling", "generatecontent", "streamgeneratecontent"].include?(capability.delete("_-"))
+        end
+      end
+
       def selected_model(selected, models)
         text = selected.to_s.sub(/ \(current\)\z/, "").strip
         known = models.find { |model| "#{model[:provider]} #{model[:id]}" == text }
         return [known[:provider], known[:id]] if known
 
         provider, model = text.split(/\s+/, 2)
-        if ["Codex", "Anthropic", "OpenRouter", "Copilot"].include?(provider) && !model.to_s.strip.empty?
-          [provider, model.strip]
-        else
-          [current_model_provider, text]
-        end
+        known_provider = ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].include?(provider) || ProviderCatalog.find_by_name(provider)
+        return [provider, model.strip] if known_provider && !model.to_s.strip.empty?
+
+        [current_model_provider, text]
+      end
+
+      def persist_model_selection(provider, model, conversation)
+        model = model.to_s.strip
+        raise "Model must be a non-empty string" if model.empty?
+
+        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
+        reload_client_config
+        refresh_conversation_runtime(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5