kward 0.79.0 → 0.80.0

data/lib/kward/rpc/plugin_chat_manager.rb

@@ -1,40 +1,33 @@
-require "securerandom"
-require "thread"
 require_relative "../cancellation"
-require_relative "../events"
 require_relative "../image_attachments"
-require_relative "../message_access"
+require_relative "../plugin_chat_runtime"
 require_relative "../plugin_registry"
-require_relative "../tools/tool_call"
-require_relative "../tab_driver"
 require_relative "attachment_normalizer"
 require_relative "transcript_normalizer"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
   module RPC
-    # Coordinates optional RPC access to plugin-owned conversational runtimes.
-    # Unlike SessionManager, this manager never creates workspace sessions,
-    # agents, or tool registries: each plugin driver owns its chat and storage.
+    # Exposes the frontend-neutral plugin chat runtime over JSON-RPC.
     class PluginChatManager
-      EVENT_LIMIT = 1_000
-      WORKER_STOP = Object.new.freeze
-
-      Chat = Struct.new(:id, :type, :driver, :queue, :worker, :running_turn_id, keyword_init: true)
-      Turn = Struct.new(:id, :chat_id, :input, :display_input, :status, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :mutex, keyword_init: true)
+      EVENT_LIMIT = PluginChatRuntime::EVENT_LIMIT
 
       def initialize(server:, client: Client.new, plugin_registry_provider: nil)
         @server = server
-        @client = client
-        @plugin_registry_provider = plugin_registry_provider
-        @chats = {}
-        @turns = {}
+        @runtime = PluginChatRuntime.new(
+          client: client,
+          plugin_registry_provider: plugin_registry_provider,
+          message_normalizer: ->(message) { TranscriptNormalizer.new([message]).normalize.first }
+        )
         @subscriptions = {}
         @mutex = Mutex.new
+        @runtime.subscribe_events { |event| notify_event(event) }
       end
 
+      attr_reader :runtime
+
       def supported_types
-        plugin_registry.tab_types.select(&:rpc)
+        @runtime.supported_types(surface: :rpc)
       end
 
       def list
@@ -42,11 +35,11 @@ module Kward
       end
 
       def open(type_id:)
-        type = supported_types.find { |entry| entry.id == type_id.to_s } || raise(ArgumentError, "Unknown RPC plugin chat: #{type_id}")
-        chat = chat_for(type)
-        return chat_payload(chat) if chat.driver.respond_to?(:transcript_page)
+        chat = @runtime.open(type_id: type_id, surface: :rpc, scope_key: "owner")
+        payload = chat_payload(chat)
+        return payload if chat.driver.respond_to?(:transcript_page)
 
-        chat_payload(chat).merge(messages: TranscriptNormalizer.new(chat.driver.messages).normalize)
+        payload.merge(messages: TranscriptNormalizer.new(chat.driver.messages).normalize)
       end
 
       def transcript(chat_id:, limit: nil, before: nil)
@@ -75,190 +68,51 @@ module Kward
       def start_turn(chat_id:, input:, attachments: [])
         chat = fetch_chat(chat_id)
         normalized_attachments = AttachmentNormalizer.new.normalize(attachments)
-        turn = Turn.new(
-          id: SecureRandom.uuid,
+        turn = @runtime.start_turn(
           chat_id: chat.id,
-          input: input_with_attachments(input, normalized_attachments),
-          display_input: input.to_s,
-          status: "queued",
-          cancellation: Cancellation.new,
-          created_at: Time.now.utc.iso8601(3),
-          events: [],
-          next_sequence: 1,
-          mutex: Mutex.new
+          input: @runtime.input_with_attachments(input, normalized_attachments),
+          display_input: input.to_s
         )
-        @mutex.synchronize { @turns[turn.id] = turn }
-        chat.queue << turn.id
-        ensure_worker(chat)
-        emit_event(turn, "turnQueued", { status: "queued" })
         turn_payload(turn)
       end
 
       def cancel_turn(turn_id:)
-        turn = fetch_turn(turn_id)
-        queued = turn.mutex.synchronize do
-          turn.cancellation.cancel!
-          turn.status == "queued"
-        end
-        emit_event(turn, "turnCancelRequested", {})
-        finish_turn(turn, "canceled") if queued
-        turn_payload(turn)
+        turn_payload(@runtime.cancel_turn(turn_id: turn_id))
       end
 
       def turn_status(turn_id:)
-        turn_payload(fetch_turn(turn_id))
+        turn_payload(@runtime.turn_status(turn_id: turn_id))
       end
 
       def turn_events(turn_id:, after_sequence: 0)
-        turn = fetch_turn(turn_id)
-        events = turn.mutex.synchronize { turn.events.select { |event| event[:sequence].to_i > after_sequence.to_i } }
-        { turn: turn_payload(turn), events: events }
+        turn = @runtime.turn_status(turn_id: turn_id)
+        {
+          turn: turn_payload(turn),
+          events: @runtime.turn_events(turn_id: turn_id, after_sequence: after_sequence)
+        }
       end
 
       def list_turns(chat_id: nil, active: false)
-        turns = @mutex.synchronize { @turns.values.dup }
-        turns.select! { |turn| turn.chat_id == chat_id.to_s } if chat_id
-        turns.select! { |turn| %w[queued running].include?(turn.status) } if active
-        { turns: turns.map { |turn| turn_payload(turn) } }
+        { turns: @runtime.list_turns(chat_id: chat_id, active: active).map { |turn| turn_payload(turn) } }
       end
 
       def shutdown
-        chats = @mutex.synchronize { @chats.values.dup }
-        chats.each do |chat|
-          chat.queue << WORKER_STOP if chat.worker&.alive?
-          chat.worker&.join(0.2)
-        end
+        @runtime.shutdown
       end
 
       private
 
-      def plugin_registry
-        return @plugin_registry_provider.call if @plugin_registry_provider
-
-        @plugin_registry ||= PluginRegistry.load
-      end
-
-      def chat_for(type)
-        @mutex.synchronize do
-          @chats[type.id] ||= begin
-            descriptor = { "kind" => "plugin", "plugin_tab_type" => type.id, "label" => type.title }
-            driver = type.handler.call(PluginTabHost.new(client: @client, workspace_root: Dir.pwd), descriptor)
-            raise "Plugin chat #{type.id.inspect} did not return a tab driver." unless driver
-
-            Chat.new(id: type.id, type: type, driver: driver, queue: Queue.new)
-          end
-        end
-      end
-
       def fetch_chat(chat_id)
-        @mutex.synchronize { @chats[chat_id.to_s] } || open(type_id: chat_id).then { @mutex.synchronize { @chats[chat_id.to_s] } }
-      end
-
-      def fetch_turn(turn_id)
-        @mutex.synchronize { @turns[turn_id.to_s] } || raise(ArgumentError, "Unknown plugin chat turn: #{turn_id}")
-      end
-
-      def ensure_worker(chat)
-        return if chat.worker&.alive?
-
-        chat.worker = Thread.new do
-          loop do
-            turn_id = chat.queue.pop
-            break if turn_id.equal?(WORKER_STOP)
-
-            turn = fetch_turn(turn_id)
-            run_turn(chat, turn) unless turn.cancellation.cancelled?
-          end
-        end
-        chat.worker.report_on_exception = false
-      end
-
-      def run_turn(chat, turn)
-        turn.mutex.synchronize do
-          return if terminal?(turn)
-
-          turn.status = "running"
-          turn.started_at = Time.now.utc.iso8601(3)
-        end
-        chat.running_turn_id = turn.id
-        emit_event(turn, "turnStarted", { status: "running" })
-        chat.driver.submit(turn.input, display_input: turn.display_input, cancellation: turn.cancellation) do |event|
-          handle_driver_event(chat, turn, event)
-        end
-        finish_turn(turn, turn.cancellation.cancelled? ? "canceled" : "completed")
-      rescue Cancellation::CancelledError
-        finish_turn(turn, "canceled")
-      rescue StandardError => e
-        turn.mutex.synchronize { turn.error = { message: e.message, code: e.class.name, fatal: false } }
-        finish_turn(turn, "failed")
-      ensure
-        chat.running_turn_id = nil if chat.running_turn_id == turn.id
-      end
-
-      def handle_driver_event(chat, turn, event)
-        notify_plugin_tab_transcript_event(chat, event) if chat.type.transcript_events
-
-        type, payload = case event
-        when Events::ReasoningDelta then ["reasoningDelta", { delta: event.delta }]
-        when Events::ReasoningBoundary then ["reasoningBoundary", {}]
-        when Events::AssistantDelta then ["assistantDelta", { delta: event.delta }]
-        when Events::AssistantMessage then ["assistantMessage", { message: TranscriptNormalizer.new([event.message]).normalize.first }]
-        when Events::Retry then ["modelRetry", retry_event_payload(event)]
-        when Events::ToolCall then ["toolCall", tool_call_payload(event.tool_call)]
-        when Events::ToolResult then ["toolResult", tool_result_payload(event.tool_call, event.content)]
-        when Events::Answer then ["answer", { content: event.content }]
-        end
-        emit_event(turn, type, payload) if type
-      end
-
-      def notify_plugin_tab_transcript_event(chat, event)
-        return if plugin_registry.transcript_event_handlers.empty?
-
-        context = PluginRegistry::Context.new(conversation: chat.driver, workspace_root: Dir.pwd)
-        plugin_registry.notify_transcript_event(event, context)
-      end
-
-      def retry_event_payload(event)
-        { provider: event.provider, model: event.model, attempt: event.attempt, maxAttempts: event.max_attempts, delaySeconds: event.delay_seconds, error: event.error, requestBytes: event.request_bytes }.compact
-      end
-
-      def tool_call_payload(tool_call)
-        { toolCallId: ToolCall.id(tool_call), toolName: ToolCall.name(tool_call), args: ToolCall.parse_arguments(ToolCall.raw_arguments(tool_call)) }.compact
-      end
-
-      def tool_result_payload(tool_call, content)
-        { toolCallId: ToolCall.id(tool_call), toolName: ToolCall.name(tool_call), result: { content: content.to_s, isError: content.to_s.start_with?("Unknown", "Invalid", "Research tool failed") } }.compact
-      end
+        return @runtime.chat(chat_id) if @runtime.chat(chat_id)
 
-      def finish_turn(turn, status)
-        event = turn.mutex.synchronize do
-          next nil if terminal?(turn)
+        chat_id = chat_id.to_s
+        type = supported_types.find { |entry| chat_id == entry.id || chat_id.start_with?("#{entry.id}:") }
+        raise ArgumentError, "Unknown plugin chat: #{chat_id}" unless type
 
-          turn.status = status
-          turn.finished_at = Time.now.utc.iso8601(3)
-          append_event(turn, "turnFinished", { status: status, error: turn.error }.compact)
-        end
-        notify_event(event) if event
-      end
+        chat = @runtime.open(type_id: type.id, surface: :rpc, scope_key: "owner")
+        raise ArgumentError, "Unknown plugin chat: #{chat_id}" unless chat.id == chat_id
 
-      def emit_event(turn, type, payload)
-        event = turn.mutex.synchronize { append_event(turn, type, payload) }
-        notify_event(event)
-      end
-
-      def append_event(turn, type, payload)
-        event = {
-          sequence: turn.next_sequence,
-          timestamp: Time.now.utc.iso8601(3),
-          chatId: turn.chat_id,
-          turnId: turn.id,
-          type: type,
-          payload: payload
-        }
-        turn.next_sequence += 1
-        turn.events << event
-        turn.events.shift while turn.events.length > EVENT_LIMIT
-        event
+        chat
       end
 
       def notify_event(event)
@@ -266,20 +120,14 @@ module Kward
         @server.notify("pluginChat/event", event) if subscribed
       end
 
-      def input_with_attachments(input, attachments)
-        return input.to_s if attachments.empty?
-
-        [{ type: "text", text: input.to_s }] + attachments.map do |attachment|
-          { type: "image", media_type: attachment[:mimeType], data: attachment[:data], alt: attachment[:alt] }
-        end
-      end
-
-      def terminal?(turn)
-        %w[completed failed canceled].include?(turn.status)
-      end
-
       def type_payload(type)
-        { id: type.id, name: type.name, title: type.title, singleton: type.singleton }.compact
+        {
+          id: type.id,
+          name: type.name,
+          title: type.title,
+          singleton: type.singleton,
+          transport: type.transport == true ? true : nil
+        }.compact
       end
 
       def transcript_page(driver, limit:, before:)
@@ -289,12 +137,23 @@ module Kward
       end
 
       def chat_payload(chat)
-        type_payload(chat.type).merge(id: chat.id, subscribed: @mutex.synchronize { @subscriptions[chat.id] == true })
+        type_payload(chat.type).merge(
+          id: chat.id,
+          subscribed: @mutex.synchronize { @subscriptions[chat.id] == true }
+        )
       end
 
       def turn_payload(turn)
         turn.mutex.synchronize do
-          { id: turn.id, chatId: turn.chat_id, status: turn.status, createdAt: turn.created_at, startedAt: turn.started_at, finishedAt: turn.finished_at, error: turn.error }.compact
+          {
+            id: turn.id,
+            chatId: turn.chat_id,
+            status: turn.status,
+            createdAt: turn.created_at,
+            startedAt: turn.started_at,
+            finishedAt: turn.finished_at,
+            error: turn.error
+          }.compact
         end
       end
     end

data/lib/kward/rpc/prompt_bridge.rb

@@ -8,8 +8,12 @@ module Kward
   module RPC
     # RPC prompt bridge for structured user questions.
     class PromptBridge
-      def initialize(server:, session_id:)
-        @server = server
+      def initialize(server: nil, session_id:, notify: nil)
+        @notify = notify || lambda do |method, payload|
+          raise ArgumentError, "PromptBridge requires a server or notify callback" unless server
+
+          server.notify(method, payload)
+        end
         @session_id = session_id
         @mutex = Mutex.new
         @condition = ConditionVariable.new
@@ -22,7 +26,7 @@ module Kward
         @mutex.synchronize { @pending_requests[request_id] = true }
         cancellation&.on_cancel { cancel_request(request_id) }
         unless cancellation&.cancelled?
-          @server.notify("tool/approvalRequested", {
+          @notify.call("tool/approvalRequested", {
             sessionId: @session_id,
             approvalRequestId: request_id,
             toolCallId: tool_call_id,
@@ -49,7 +53,7 @@ module Kward
         @mutex.synchronize { @pending_requests[request_id] = true }
         cancellation&.on_cancel { cancel_request(request_id) }
         unless cancellation&.cancelled?
-          @server.notify("ui/question", {
+          @notify.call("ui/question", {
             sessionId: @session_id,
             questionRequestId: request_id,
             questions: questions

data/lib/kward/rpc/redactor.rb

@@ -37,7 +37,7 @@ module Kward
 
       def secret_key?(key)
         text = key.to_s
-        return false if text == "apiKeyProviders"
+        return false if ["apiKeyProviders", "privateCredentialStorage", "storedCredentialType"].include?(text)
 
         text.match?(SECRET_KEYS)
       end

data/lib/kward/rpc/server.rb

@@ -3,6 +3,7 @@ require_relative "../model/client"
 require_relative "../config_files"
 require_relative "../memory/manager"
 require_relative "../plugin_registry"
+require_relative "../transport"
 require_relative "../prompts/commands"
 require_relative "../tools/registry"
 require_relative "../workspace_factory"
@@ -15,6 +16,7 @@ require_relative "redactor"
 require_relative "session_manager"
 require_relative "plugin_chat_manager"
 require_relative "transport"
+require_relative "../transport/plugin_chat_gateway"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -59,7 +61,7 @@ module Kward
       ].freeze
       TURN_METHODS = ["turns/start", "turns/cancel", "turns/status", "turns/events", "turns/list", "turns/listActive"].freeze
       PLUGIN_CHAT_METHODS = ["pluginChats/list", "pluginChats/open", "pluginChats/transcript", "pluginChats/subscribe", "pluginChats/unsubscribe", "pluginChats/turns/start", "pluginChats/turns/cancel", "pluginChats/turns/status", "pluginChats/turns/events", "pluginChats/turns/list", "pluginChats/turns/listActive"].freeze
-      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set"].freeze
+      MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set", "models/refresh"].freeze
       RUNTIME_METHODS = ["runtime/state", "runtime/stats"].freeze
       RUNTIME_SETTING_METHODS = ["runtime/updateSetting", "runtime/reload"].freeze
       AUTH_METHODS = [
@@ -80,6 +82,7 @@ module Kward
       LIFECYCLE_HOOK_METHODS = ["hooks/logs"].freeze
       UI_METHODS = ["ui/answerQuestion"].freeze
       TOOL_APPROVAL_METHODS = ["tool/answerApproval"].freeze
+      TRANSPORT_METHODS = ["transports/list", "transports/status"].freeze
       SESSION_EVENT_NOTIFICATION = "session/event"
       SESSION_UPDATED_NOTIFICATION = "session/updated"
       TURN_EVENT_NOTIFICATION = "turn/event"
@@ -129,10 +132,23 @@ module Kward
           client: client,
           plugin_registry_provider: -> { @session_manager.plugin_registry }
         )
+        @transport_manager = Kward::Transport::Manager.new(
+          registry: @session_manager.plugin_registry,
+          gateway: lambda { |transport_id|
+            Kward::Transport::Gateway.new(session_manager: @session_manager, transport_id: transport_id)
+          },
+          plugin_chat_gateway: lambda { |transport_id|
+            Kward::Transport::PluginChatGateway.new(runtime: @plugin_chat_manager.runtime, transport_id: transport_id)
+          },
+          config_provider: ->(transport_id) { ConfigFiles.transport_config(transport_id) }
+        )
         @auth_manager = AuthManager.new(server: self, config_manager: @config_manager)
         @shutdown = false
+        @shutdown_complete = false
       end
 
+      attr_reader :session_manager, :plugin_chat_manager
+
       # Reads framed JSON-RPC messages until shutdown or EOF.
       #
       # @return [void]
@@ -150,8 +166,17 @@ module Kward
           end
         end
       ensure
+        shutdown
+      end
+
+      def shutdown
+        return if @shutdown_complete
+
+        @shutdown = true
+        @transport_manager.shutdown
         @plugin_chat_manager.shutdown
         @session_manager.shutdown_sessions
+        @shutdown_complete = true
       end
 
       # Sends a redacted JSON-RPC notification to the client.
@@ -229,6 +254,10 @@ module Kward
           @session_manager.tool_schemas(session_id: params["sessionId"])
         when MCP_METHODS[0]
           MCPStatus.new(config_manager: @config_manager).to_h
+        when TRANSPORT_METHODS[0]
+          { transports: @transport_manager.list }
+        when TRANSPORT_METHODS[1]
+          params["name"] ? @transport_manager.status(params["name"]) : { transports: @transport_manager.status }
         when PROMPT_METHODS[0]
           prompts_list
         when PROMPT_METHODS[1]
@@ -241,6 +270,8 @@ module Kward
           models_set(params)
         when MODEL_METHODS[3]
           reasoning_set(params)
+        when MODEL_METHODS[4]
+          models_refresh(params)
         when RUNTIME_METHODS[0]
           @session_manager.runtime_state(session_id: params.fetch("sessionId"))
         when RUNTIME_METHODS[1]
@@ -429,7 +460,14 @@ module Kward
             compact: { supported: true, method: SESSION_METHODS[5], notification: SESSION_EVENT_NOTIFICATION, events: ["compactionStart", "compactionEnd"] },
             import: { supported: false },
             tree: { supported: true, method: SESSION_METHODS[8], labels: true, labelTimestamps: true, navigate: true, summarize: true, shape: "kward-tree-items-v1" },
-            updates: { supported: false, notification: SESSION_UPDATED_NOTIFICATION }
+            updates: { supported: false, notification: SESSION_UPDATED_NOTIFICATION },
+            worktrees: { supported: false, reason: "interactiveTuiOnly" }
+          },
+          transports: {
+            supported: true,
+            methods: TRANSPORT_METHODS,
+            startMode: "cliOnly",
+            entries: @transport_manager.list
           },
           pluginChats: {
             supported: @plugin_chat_manager.supported_types.any?,
@@ -437,7 +475,7 @@ module Kward
             notification: "pluginChat/event",
             subscriptions: { supported: true, methods: PLUGIN_CHAT_METHODS.values_at(3, 4), requiredForLiveEvents: true },
             attachments: { supported: true, method: PLUGIN_CHAT_METHODS[5], encoding: "base64", mimeTypes: SessionManager::RPC_IMAGE_MIME_TYPES, maxBytes: SessionManager::RPC_ATTACHMENT_MAX_BYTES },
-            types: @plugin_chat_manager.supported_types.map { |type| { id: type.id, name: type.name, title: type.title, singleton: type.singleton }.compact }
+            types: @plugin_chat_manager.supported_types.map { |type| { id: type.id, name: type.name, title: type.title, singleton: type.singleton, transport: type.transport == true ? true : nil }.compact }
           },
           turns: {
             mode: "async",
@@ -493,7 +531,7 @@ module Kward
             methods: MODEL_METHODS,
             fields: ["provider", "id", "name", "reasoning", "reasoningEffort", "contextWindow"],
             scopedModels: false,
-            openRouterRefresh: { supported: false, reason: "cliOnlyCacheRefresh" }
+            refresh: { supported: true, method: MODEL_METHODS[4], providerParameter: true }
           },
           runtime: {
             supported: true,
@@ -522,11 +560,19 @@ module Kward
           },
           auth: {
             supported: true,
-            providerFormat: "kward-auth-v1",
+            providerFormat: "kward-auth-v2",
             methods: AUTH_METHODS,
-            oauthProviders: ["openai", "anthropic", "github"],
-            unsupportedOAuthProviders: { github: "CLI-only GitHub login for Copilot scaffolding; RPC login is not implemented yet." },
-            apiKeyProviders: ["openrouter"],
+            providerCatalog: true,
+            authenticationMethods: ["api_key", "oauth"],
+            oauthProviders: ["openai", "anthropic"],
+            unsupportedOAuthProviders: {
+              copilot: "OAuth login is available only in the interactive CLI.",
+              openrouter: "Official PKCE is documented, but Kward has not implemented it.",
+              xai: "No official stable third-party OAuth flow is available."
+            },
+            apiKeyProviders: ProviderCatalog.api_key_providers.map(&:id),
+            privateCredentialStorage: true,
+            sanitizedStatus: true,
             logout: true
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
@@ -775,17 +821,21 @@ module Kward
       end
 
       def auth_login_with_api_key(params)
-        result = @auth_manager.login_with_api_key(provider_id: params.fetch("providerId"), api_key: params.fetch("apiKey"))
+        result = @auth_manager.login_with_api_key(provider_id: params.fetch("providerId"), api_key: params.fetch("apiKey"), configuration: params["configuration"])
         @session_manager.refresh_client_config
         result
       end
 
       def auth_logout_provider(params)
-        result = @auth_manager.logout_provider(provider_id: params.fetch("providerId"))
+        result = @auth_manager.logout_provider(provider_id: params.fetch("providerId"), auth_method: params["authMethod"])
         @session_manager.refresh_client_config
         result
       end
 
+      def models_refresh(params)
+        { models: @session_manager.refresh_models(provider: params["provider"]) }
+      end
+
       def models_current
         @session_manager.current_model
       end