kward 0.83.0 → 0.85.0

data/lib/kward/{interactive_pty_runner.rb → pty/interactive_runner.rb}

@@ -1,8 +1,9 @@
 require "io/console"
 require "pty"
 require "timeout"
-require_relative "local_pty_command_runner"
-require_relative "pty_output_sink"
+require_relative "local_pty_runner"
+require_relative "output_sink"
+require_relative "detached_run"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -10,7 +11,7 @@ module Kward
   # This is intentionally low level: UI orchestration decides when terminal
   # ownership is handed to the child process and how the result is presented.
   class InteractivePtyRunner
-    Result = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
+    Result = Struct.new(:exit_status, :input_forwarded, :tab_action, :background, keyword_init: true)
 
     READ_SIZE = 4096
 
@@ -19,28 +20,43 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:)
-      pid = nil
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:, tab_action_handler: nil, on_detach: nil)
+      reader, writer, pid = PTY.spawn(env.to_h, *command, chdir: cwd.to_s)
       status = nil
-      writer = nil
       input_forwarded = false
-
-      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, child_writer, child_pid|
-        pid = child_pid
-        writer = child_writer
-        update_window_size(reader, pid)
-        with_raw_input(input) do
-          input_forwarded = drain_initial_input(input, writer, sink)
-          status, forwarded = forward_io(reader, writer, pid, input, sink)
+      tab_action = nil
+      forwarded = false
+      detached = nil
+
+      update_window_size(reader, pid)
+      with_raw_input(input) do
+        input_forwarded, tab_action = drain_initial_input(input, writer, sink, tab_action_handler: tab_action_handler)
+        if tab_action && on_detach
+          detached_sink = on_detach.call
+          sink.finish if sink.respond_to?(:finish)
+          detached = detach_process(reader, writer, pid, detached_sink, input_forwarded)
+          reader = writer = pid = nil
+        elsif tab_action
+          status = terminate_and_reap(pid)
+        else
+          status, forwarded, tab_action = forward_io(reader, writer, pid, input, sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
           input_forwarded ||= forwarded
+          if tab_action && on_detach
+            detached_sink = on_detach.call
+            sink.finish if sink.respond_to?(:finish)
+            detached = detach_process(reader, writer, pid, detached_sink, input_forwarded)
+            reader = writer = pid = nil
+          end
         end
-        sink.finish if sink.respond_to?(:finish)
-        status ||= wait_for_status(pid)
+        input_forwarded ||= forwarded
       end
+      sink.finish if sink.respond_to?(:finish) && !detached
+      status ||= wait_for_status(pid) if pid
 
-      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
+      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded, tab_action: tab_action, background: detached)
     ensure
       writer&.close unless writer&.closed?
+      reader&.close unless reader&.closed?
       terminate_and_reap(pid) if pid && status.nil?
     end
 
@@ -60,23 +76,39 @@ module Kward
       yield
     end
 
-    def drain_initial_input(input, writer, sink)
+    def drain_initial_input(input, writer, sink, tab_action_handler: nil)
       forwarded = false
       loop do
         chunk = input.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
+        filtered = tab_action_handler&.call(chunk)
+        if filtered
+          tab_action = filtered[:tab_action]
+          chunk = filtered[:input].to_s
+          if tab_action
+            unless chunk.empty?
+              sink.input_forwarded if sink.respond_to?(:input_forwarded)
+              writer.write(chunk)
+              writer.flush
+              forwarded = true
+            end
+            return [forwarded, tab_action]
+          end
+        end
+        next if chunk.empty?
+
         sink.input_forwarded if sink.respond_to?(:input_forwarded)
         writer.write(chunk)
         forwarded = true
       end
       writer.flush
-      forwarded
+      [forwarded, nil]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      forwarded
+      [forwarded, nil]
     end
 
-    def forward_io(reader, writer, pid, input, sink)
+    def forward_io(reader, writer, pid, input, sink, tab_action_handler: nil, on_detach: nil)
       input_open = true
       input_forwarded = false
       loop do
@@ -86,19 +118,45 @@ module Kward
         readable = IO.select(readers, nil, nil, 0.02)&.first || []
         forward_pty_output(reader, sink) if readable.include?(reader)
         if input_open && readable.include?(input)
-          input_open, forwarded = forward_input(input, writer, sink)
+          input_open, forwarded, tab_action = forward_input(input, writer, sink, tab_action_handler: tab_action_handler)
           input_forwarded ||= forwarded
+          return [nil, input_forwarded, tab_action] if tab_action && on_detach
+          return [terminate_and_reap(pid), input_forwarded, tab_action] if tab_action
         end
 
         status = finished_status(pid)
         next unless status
 
-        return [finish_stopped_process(pid), input_forwarded] if status.stopped?
+        return [finish_stopped_process(pid), input_forwarded, nil] if status.stopped?
 
         drain_pty_output(reader, sink)
-        return [status, input_forwarded]
+        return [status, input_forwarded, nil]
       rescue Errno::EIO
-        return [wait_for_status(pid), input_forwarded]
+        return [wait_for_status(pid), input_forwarded, nil]
+      end
+    end
+
+    def detach_process(reader, writer, pid, sink, input_forwarded)
+      DetachedRun.new(sink: sink, canceler: -> { terminate_process_group(pid) }) do
+        status = nil
+        begin
+          loop do
+            readable, = IO.select([reader], nil, nil, 0.02)&.first
+            forward_pty_output(reader, sink) if readable
+            status = finished_status(pid)
+            next unless status
+
+            drain_pty_output(reader, sink)
+            break
+          end
+        rescue Errno::EIO
+          status = wait_for_status(pid)
+        ensure
+          sink.finish if sink.respond_to?(:finish)
+          writer.close unless writer.closed?
+          reader.close unless reader.closed?
+        end
+        Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
       end
     end
 
@@ -125,17 +183,33 @@ module Kward
       nil
     end
 
-    def forward_input(input, writer, sink)
+    def forward_input(input, writer, sink, tab_action_handler: nil)
       chunk = input.read_nonblock(READ_SIZE, exception: false)
-      return [false, false] if chunk.nil?
-      return [true, false] if chunk == :wait_readable
+      return [false, false, nil] if chunk.nil?
+      return [true, false, nil] if chunk == :wait_readable
+
+      filtered = tab_action_handler&.call(chunk)
+      if filtered
+        tab_action = filtered[:tab_action]
+        chunk = filtered[:input].to_s
+        if tab_action
+          unless chunk.empty?
+            sink.input_forwarded if sink.respond_to?(:input_forwarded)
+            writer.write(chunk)
+            writer.flush
+            return [true, true, tab_action]
+          end
+          return [true, false, tab_action]
+        end
+      end
+      return [true, false, nil] if chunk.empty?
 
       sink.input_forwarded if sink.respond_to?(:input_forwarded)
       writer.write(chunk)
       writer.flush
-      [true, true]
+      [true, true, nil]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      [false, false]
+      [false, false, nil]
     end
 
     def update_window_size(reader, pid)

data/lib/kward/{local_command_runner.rb → pty/local_command_runner.rb}

@@ -1,7 +1,7 @@
 require "open3"
 require "thread"
 require "timeout"
-require_relative "cancellation"
+require_relative "../cancellation"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{local_pty_command_runner.rb → pty/local_pty_runner.rb}

@@ -1,7 +1,7 @@
 require "io/console"
 require "pty"
 require "timeout"
-require_relative "cancellation"
+require_relative "../cancellation"
 require_relative "local_command_runner"
 
 # Namespace for the Kward CLI agent runtime.
@@ -52,7 +52,8 @@ module Kward
             readable, = IO.select([reader], nil, nil, 0.02)
             next unless readable
 
-            chunk = read_chunk(reader)
+            chunk = reader.read_nonblock(READ_SIZE, exception: false)
+            next if chunk == :wait_readable
             break if chunk.nil?
 
             chunk = normalize_line_endings(chunk)
@@ -102,13 +103,6 @@ module Kward
       [DEFAULT_ROWS, DEFAULT_COLUMNS]
     end
 
-    def read_chunk(reader)
-      reader.read_nonblock(READ_SIZE, exception: false).tap do |chunk|
-        return nil if chunk.nil?
-        return nil if chunk == :wait_readable
-      end
-    end
-
     def normalize_line_endings(chunk)
       chunk.gsub("\r\r\n", "\n").gsub("\r\n", "\n")
     end

data/lib/kward/{pty_output_sink.rb → pty/output_sink.rb}

@@ -1,5 +1,57 @@
+require "thread"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
+  # Retains output while a detached PTY command runs without terminal ownership.
+  class BufferedPtyOutputSink
+    def initialize(max_capture_bytes:, initial_output: nil, initial_truncated: false)
+      @max_capture_bytes = max_capture_bytes
+      @captured_output = +"".b
+      @truncated = initial_truncated
+      @mutex = Mutex.new
+      write(initial_output) unless initial_output.to_s.empty?
+    end
+
+    def captured_output
+      @mutex.synchronize { @captured_output.dup }
+    end
+
+    def write(chunk)
+      value = chunk.to_s.b
+      return if value.empty?
+
+      @mutex.synchronize do
+        remaining = @max_capture_bytes - @captured_output.bytesize
+        if value.bytesize > remaining
+          @captured_output << value.byteslice(0, remaining) if remaining.positive?
+          @truncated = true
+        else
+          @captured_output << value
+        end
+      end
+    end
+
+    def flush
+      nil
+    end
+
+    def finish
+      nil
+    end
+
+    def transcript_safe?
+      true
+    end
+
+    def pre_input_capture_only?
+      true
+    end
+
+    def truncated?
+      @mutex.synchronize { @truncated }
+    end
+  end
+
   # Forwards PTY output immediately and optionally keeps a bounded byte copy.
   #
   # The runner only depends on the sink's `write` method and optional `flush`

data/lib/kward/{pty_transcript_normalizer.rb → pty/transcript_normalizer.rb}

@@ -1,4 +1,4 @@
-require_relative "ansi"
+require_relative "../terminal/ansi"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/rpc/plugin_chat_manager.rb

@@ -1,7 +1,7 @@
 require_relative "../cancellation"
 require_relative "../image_attachments"
-require_relative "../plugin_chat_runtime"
-require_relative "../plugin_registry"
+require_relative "../plugins/chat_runtime"
+require_relative "../plugins/registry"
 require_relative "attachment_normalizer"
 require_relative "transcript_normalizer"
 
@@ -30,21 +30,25 @@ module Kward
         @runtime.supported_types(surface: :rpc)
       end
 
+      def type_entries
+        supported_types.map { |type| type_payload(type) }
+      end
+
       def list
-        { chats: supported_types.map { |type| type_payload(type) } }
+        { chats: type_entries }
       end
 
       def open(type_id:)
         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)
+        return payload if transcript_paging?(chat)
 
         payload.merge(messages: TranscriptNormalizer.new(chat.driver.messages).normalize)
       end
 
       def transcript(chat_id:, limit: nil, before: nil)
         chat = fetch_chat(chat_id)
-        page = transcript_page(chat.driver, limit: limit, before: before)
+        page = transcript_page(chat, limit: limit, before: before)
         {
           chat: chat_payload(chat),
           messages: TranscriptNormalizer.new(page.fetch(:messages)).normalize,
@@ -70,7 +74,7 @@ module Kward
         normalized_attachments = AttachmentNormalizer.new.normalize(attachments)
         turn = @runtime.start_turn(
           chat_id: chat.id,
-          input: @runtime.input_with_attachments(input, normalized_attachments),
+          input: @runtime.input_with_attachments(input, normalized_attachments, capabilities: chat.type.capabilities),
           display_input: input.to_s
         )
         turn_payload(turn)
@@ -121,19 +125,35 @@ module Kward
       end
 
       def type_payload(type)
-        {
+        payload = {
           id: type.id,
           name: type.name,
           title: type.title,
           singleton: type.singleton,
           transport: type.transport == true ? true : nil
         }.compact
+        return payload unless type.capabilities.declared?
+
+        capabilities = type.capabilities.to_h
+        payload.merge(
+          apiVersion: capabilities.fetch(:api_version),
+          capabilities: {
+            attachments: capabilities.fetch(:attachments),
+            steering: capabilities.fetch(:steering),
+            transcriptPaging: capabilities.fetch(:transcript_paging)
+          }
+        )
+      end
+
+      def transcript_paging?(chat)
+        capabilities = chat.type.capabilities
+        capabilities.declared? ? capabilities.transcript_paging? : chat.driver.respond_to?(:transcript_page)
       end
 
-      def transcript_page(driver, limit:, before:)
-        return { messages: driver.messages, has_more: false } unless limit && driver.respond_to?(:transcript_page)
+      def transcript_page(chat, limit:, before:)
+        return { messages: chat.driver.messages, has_more: false } unless limit && transcript_paging?(chat)
 
-        driver.transcript_page(limit: limit, before: before)
+        chat.driver.transcript_page(limit: limit, before: before)
       end
 
       def chat_payload(chat)

data/lib/kward/rpc/prompt_bridge.rb

@@ -74,6 +74,31 @@ module Kward
         answer_raw(request_id, normalize_answers(answers))
       end
 
+      def request_plugin_ui(kind, payload, cancellation: nil)
+        request_id = SecureRandom.uuid
+        @mutex.synchronize { @pending_requests[request_id] = true }
+        cancellation&.on_cancel { cancel_request(request_id) }
+        unless cancellation&.cancelled?
+          @notify.call("ui/request", {
+            sessionId: @session_id,
+            requestId: request_id,
+            kind: kind.to_s,
+            payload: payload
+          })
+        end
+
+        @mutex.synchronize do
+          @condition.wait(@mutex) until @answers.key?(request_id)
+          answer = @answers.delete(request_id)
+          @pending_requests.delete(request_id)
+          answer
+        end
+      end
+
+      def answer_plugin_ui(request_id, value)
+        answer_raw(request_id, value)
+      end
+
       def cancel_request(request_id)
         @mutex.synchronize do
           request_id = request_id.to_s

data/lib/kward/rpc/server.rb

@@ -2,11 +2,11 @@ require "json"
 require_relative "../model/client"
 require_relative "../config_files"
 require_relative "../memory/manager"
-require_relative "../plugin_registry"
+require_relative "../plugins/registry"
 require_relative "../transport"
 require_relative "../prompts/commands"
 require_relative "../tools/registry"
-require_relative "../workspace_factory"
+require_relative "../workspace/factory"
 require_relative "../telemetry/logger"
 require_relative "../telemetry/stats"
 require_relative "auth_manager"
@@ -75,18 +75,22 @@ module Kward
         "memory/why", "memory/summarize"
       ].freeze
       COMMAND_METHODS = ["commands/list", "commands/run"].freeze
+      PLUGIN_ACTION_METHODS = ["pluginActions/list", "pluginActions/run"].freeze
       SKILL_CAPTURE_METHODS = ["skills/captureSessions", "skills/captureDraft", "skills/saveCapturedDraft"].freeze
       STARTUP_RESOURCE_METHODS = ["resources/startup"].freeze
       CONFIG_METHODS = ["config/read", "config/update"].freeze
       LOGGING_METHODS = ["logging/stats", "logging/tokenCsv"].freeze
       LIFECYCLE_HOOK_METHODS = ["hooks/logs"].freeze
-      UI_METHODS = ["ui/answerQuestion"].freeze
+      UI_METHODS = ["ui/answerQuestion", "ui/answerRequest"].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"
       UI_QUESTION_NOTIFICATION = "ui/question"
+      UI_REQUEST_NOTIFICATION = "ui/request"
+      UI_PROGRESS_NOTIFICATION = "ui/progress"
+      UI_NOTIFICATION = "ui/notification"
       UI_FOOTER_NOTIFICATION = "ui/footer"
       TOOL_APPROVAL_NOTIFICATION = "tool/approvalRequested"
       HOOK_EVENT_NOTIFICATION = "hook/event"
@@ -105,6 +109,7 @@ module Kward
         auth: AUTH_METHODS,
         memory: MEMORY_METHODS,
         commands: COMMAND_METHODS,
+        plugin_actions: PLUGIN_ACTION_METHODS,
         skill_capture: SKILL_CAPTURE_METHODS,
         startup_resources: STARTUP_RESOURCE_METHODS,
         config: CONFIG_METHODS,
@@ -176,6 +181,7 @@ module Kward
         @transport_manager.shutdown
         @plugin_chat_manager.shutdown
         @session_manager.shutdown_sessions
+        @session_manager.shutdown_plugins
         @shutdown_complete = true
       end
 
@@ -284,6 +290,10 @@ module Kward
           commands_list(params)
         when COMMAND_METHODS[1]
           commands_run(params)
+        when PLUGIN_ACTION_METHODS[0]
+          plugin_actions_list(params)
+        when PLUGIN_ACTION_METHODS[1]
+          plugin_actions_run(params)
         when SKILL_CAPTURE_METHODS[0]
           { sessions: @session_manager.skill_capture_sessions }
         when SKILL_CAPTURE_METHODS[1]
@@ -421,6 +431,8 @@ module Kward
           @plugin_chat_manager.list_turns(chat_id: params["chatId"], active: true)
         when UI_METHODS[0]
           @session_manager.answer_question(session_id: params.fetch("sessionId"), question_request_id: params.fetch("questionRequestId"), answers: params.fetch("answers"))
+        when UI_METHODS[1]
+          @session_manager.answer_plugin_ui(session_id: params.fetch("sessionId"), request_id: params.fetch("requestId"), value: params["value"])
         when TOOL_APPROVAL_METHODS[0]
           @session_manager.answer_tool_approval(session_id: params.fetch("sessionId"), approval_request_id: params.fetch("approvalRequestId"), approved: params.fetch("approved"))
         else
@@ -469,13 +481,27 @@ module Kward
             startMode: "cliOnly",
             entries: @transport_manager.list
           },
+          plugins: {
+            apiVersion: PluginRegistry::PLUGIN_API_VERSION,
+            identified: @session_manager.plugin_registry.plugins.map do |plugin|
+              { id: plugin.id, version: plugin.version, apiVersion: plugin.api_version }
+            end
+          },
+          pluginTools: {
+            supported: true,
+            registered: @session_manager.plugin_registry.tools.length,
+            discoveryMethod: TOOL_METHODS.first,
+            source: "plugin",
+            executionProfileFiltering: true,
+            permissionPolicy: true
+          },
           pluginChats: {
             supported: @plugin_chat_manager.supported_types.any?,
             methods: PLUGIN_CHAT_METHODS,
             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, transport: type.transport == true ? true : nil }.compact }
+            types: @plugin_chat_manager.type_entries
           },
           turns: {
             mode: "async",
@@ -513,6 +539,7 @@ module Kward
             reasoning: { start: false, delta: true, boundary: true, end: false },
             modelRetry: { supported: true, event: "modelRetry" },
             steering: { supported: @session_manager.in_flight_steer_supported?, event: "turnSteered", mode: @session_manager.in_flight_steer_supported? ? "native" : "unsupported" },
+            pluginCommands: { structuredResult: "pluginCommandResult" },
             tools: { call: true, update: true, result: true, normalizedMetadata: true, diffs: true, firstChangedLine: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
             errors: true,
             sessionUpdates: false
@@ -577,7 +604,31 @@ module Kward
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
           stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: [] },
-          commands: { supported: true, methods: COMMAND_METHODS, method: COMMAND_METHODS[0], runMethod: COMMAND_METHODS[1], sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
+          commands: {
+            supported: true,
+            methods: COMMAND_METHODS,
+            method: COMMAND_METHODS[0],
+            runMethod: COMMAND_METHODS[1],
+            sources: ["builtin", "prompt", "skill", "plugin"],
+            executableSources: ["builtin", "plugin"],
+            typedArguments: { supported: true, schema: "jsonSchemaObject", textSyntax: "shellFlags", legacyRawStrings: true },
+            structuredResults: true,
+            modelTurns: {
+              supported: true, method: "turns/start", synchronous: false,
+              inputRole: "system", codexInputRole: "developer", scope: "turn", maxSystemBytes: PluginTurnRequest::MAX_SYSTEM_BYTES,
+              pluginChats: false, pan: false
+            }
+          },
+          pluginActions: {
+            supported: true,
+            methods: PLUGIN_ACTION_METHODS,
+            registered: @session_manager.plugin_actions.length,
+            namespace: "pluginId/actionName",
+            arguments: "jsonSchemaObject",
+            structuredResults: true,
+            blockingUi: false,
+            localTui: false
+          },
           skillCapture: { supported: true, methods: SKILL_CAPTURE_METHODS, destination: "personal", source: "savedSessionActiveLeaf", reviewRequired: true, overwrite: "explicit", autoActivate: false },
           projectSkillTrust: { supported: false, trustRequired: true, reason: "RPC has no interactive trust decision bridge; project skills remain skipped unless globally enabled." },
           mcp: {
@@ -599,12 +650,14 @@ module Kward
           scratchpad: { supported: false, reason: "interactiveTuiOnly" },
           extensionUi: {
             question: { supported: true, notification: UI_QUESTION_NOTIFICATION, method: UI_METHODS.first, maxQuestions: 4, multiSelect: false, preview: false },
-            select: false,
-            confirm: false,
-            input: false,
+            select: { supported: true, notification: UI_REQUEST_NOTIFICATION, method: UI_METHODS[1], maxOptions: PluginUI::MAX_OPTIONS },
+            confirm: { supported: true, notification: UI_REQUEST_NOTIFICATION, method: UI_METHODS[1] },
+            input: { supported: true, notification: UI_REQUEST_NOTIFICATION, method: UI_METHODS[1], maxBytes: PluginUI::MAX_TEXT_BYTES },
+            progress: { supported: true, notification: UI_PROGRESS_NOTIFICATION },
+            notify: { supported: true, notification: UI_NOTIFICATION, levels: PluginUI::NOTIFICATION_LEVELS.map(&:to_s) },
             editor: false,
             widgets: false,
-            footer: { supported: true, notification: UI_FOOTER_NOTIFICATION },
+            footer: { supported: true, notification: UI_FOOTER_NOTIFICATION, segments: true, tooltip: true, priorities: PluginRegistry::STATUS_PRIORITIES.keys.map(&:to_s) },
             custom: false,
             terminalInput: false
           },
@@ -789,8 +842,12 @@ module Kward
             argumentHint: command.argument_hint,
             source: "plugin",
             path: command.path,
-            executable: true
-          }
+            pluginId: command.plugin_id,
+            executable: true,
+            typed: command.typed?,
+            schema: command.schema,
+            positionals: command.positionals
+          }.compact
         end
         { commands: builtins + prompts + skills + plugins }
       end
@@ -799,7 +856,29 @@ module Kward
         @session_manager.run_command(
           session_id: params.fetch("sessionId"),
           command: params.fetch("name"),
-          arguments: params["arguments"] || ""
+          arguments: params.key?("arguments") ? params["arguments"] : ""
+        )
+      end
+
+      def plugin_actions_list(params)
+        @session_manager.runtime_state(session_id: params.fetch("sessionId"))
+        actions = @session_manager.plugin_actions.map do |action|
+          {
+            id: action.id,
+            name: action.name,
+            pluginId: action.plugin_id,
+            description: action.description,
+            schema: action.schema
+          }
+        end
+        { actions: actions }
+      end
+
+      def plugin_actions_run(params)
+        @session_manager.run_plugin_action(
+          session_id: params.fetch("sessionId"),
+          id: params.fetch("id"),
+          arguments: params.key?("arguments") ? params["arguments"] : {}
         )
       end