copilot-sdk-supercharged 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19d158b60339fae57a72d251e121914c0bd9881663f62dc0dfb3429589ccbced
-  data.tar.gz: aaade275a2913861110d2f3428cef4a66b681a6b84ca5784c7841ac0370dcf3b
+  metadata.gz: 392f8acf685d1aa8978a06e40ebd965ab0ca2a7420a7194a91d5b89f1468e925
+  data.tar.gz: 8b91a8a18f10a8bb5e0b85ffee7eabf309246b268303436741a3d87dceca28fe
 SHA512:
-  metadata.gz: 9aeb65b748e0249a97df087e257c31ebf2a9e5fa05522f8de892fe3d4ea87c9396ce550c4419ed7b4944761f29208e7a973144a559c3f241d14795271f6de69a
-  data.tar.gz: 4f3ba9365d11a5310620ea853407917e31b9a69f6c10a73a92e46b0c0c425da24b8048cf9f0e5207aceebe818ccd668d5adc0a745008cb2a5bbb5504c87c89a8
+  metadata.gz: 333bb586d18fa374572905b4044cceef361659eba6b7be7dcbbfdc2c621fa9ac0ce400a6b64e28549ec6d84fbf8279fe93d30222d3ace4ae715d6aa6f33a154d
+  data.tar.gz: ffd63d77549c4e8e6d41cb242012a2af2eae8a01faecb773055cc158ce59386cdf68ad10315653bb3a9aad6dd1ed0e768d14b87a23785fb8e030545dbb38c16d

data/lib/copilot/client.rb

@@ -55,7 +55,8 @@ module Copilot
       auto_restart: true,
       env: nil,
       github_token: nil,
-      use_logged_in_user: nil
+      use_logged_in_user: nil,
+      on_get_trace_context: nil
     )
       # Validate mutually exclusive options
       if cli_url && (use_stdio == false || cli_path)
@@ -95,6 +96,7 @@ module Copilot
         env: env,
         github_token: github_token,
         use_logged_in_user: use_logged_in_user,
+        on_get_trace_context: on_get_trace_context,
       )
 
       @process    = nil
@@ -281,6 +283,10 @@ module Copilot
       session._register_permission_handler(config[:on_permission_request]) if config[:on_permission_request]
       session._register_user_input_handler(config[:on_user_input_request]) if config[:on_user_input_request]
       session._register_hooks(config[:hooks]) if config[:hooks]
+      session._register_exit_plan_mode_handler(config[:on_exit_plan_mode]) if config[:on_exit_plan_mode]
+      if @options.on_get_trace_context
+        session._register_trace_context_provider(@options.on_get_trace_context)
+      end
 
       @sessions_lock.synchronize { @sessions[session_id] = session }
       session
@@ -305,6 +311,10 @@ module Copilot
       session._register_permission_handler(config[:on_permission_request]) if config[:on_permission_request]
       session._register_user_input_handler(config[:on_user_input_request]) if config[:on_user_input_request]
       session._register_hooks(config[:hooks]) if config[:hooks]
+      session._register_exit_plan_mode_handler(config[:on_exit_plan_mode]) if config[:on_exit_plan_mode]
+      if @options.on_get_trace_context
+        session._register_trace_context_provider(@options.on_get_trace_context)
+      end
 
       @sessions_lock.synchronize { @sessions[resumed_id] = session }
       session
@@ -633,6 +643,10 @@ module Copilot
       @rpc_client.on_request("hooks.invoke") do |params|
         handle_hooks_invoke(params)
       end
+
+      @rpc_client.on_request("exitPlanMode.request") do |params|
+        handle_exit_plan_mode_request(params)
+      end
     end
 
     def verify_protocol_version
@@ -769,6 +783,21 @@ module Copilot
       { output: output }
     end
 
+    def handle_exit_plan_mode_request(params)
+      session_id = params["sessionId"]
+      raise "Invalid exit plan mode request payload" unless session_id
+
+      session = @sessions_lock.synchronize { @sessions[session_id] }
+      raise "Session not found: #{session_id}" unless session
+
+      begin
+        result = session._handle_exit_plan_mode_request(params)
+        result
+      rescue StandardError
+        { approved: true }
+      end
+    end
+
     # ---- Payload builders ----
 
     def build_create_session_payload(config)
@@ -789,6 +818,7 @@ module Copilot
       payload[:requestPermission] = true if config[:on_permission_request]
       payload[:requestUserInput] = true if config[:on_user_input_request]
       payload[:hooks] = true if config[:hooks]&.respond_to?(:any_handler?) && config[:hooks].any_handler?
+      payload[:requestExitPlanMode] = true if config[:on_exit_plan_mode]
       payload[:workingDirectory] = config[:working_directory] if config[:working_directory]
       payload[:streaming] = config[:streaming] unless config[:streaming].nil?
 
@@ -796,6 +826,9 @@ module Copilot
         payload[:provider] = config[:provider].respond_to?(:to_wire) ? config[:provider].to_wire : config[:provider]
       end
 
+      token = config[:auth_token] || config[:github_token] || config[:git_hub_token]
+      payload[:gitHubToken] = token if token
+
       payload[:mcpServers] = config[:mcp_servers] if config[:mcp_servers]
 
       if config[:custom_agents]

data/lib/copilot/json_rpc_client.rb

@@ -79,7 +79,8 @@ module Copilot
     # @return [Object] the +result+ from the JSON-RPC response
     # @raise [JsonRpcError] if the server returns an error
     # @raise [Timeout::Error] if the request times out
-    def request(method, params = nil, timeout: 30)
+    def request(method, params = nil, timeout: 30, **kwargs)
+      params = kwargs if params.nil? && !kwargs.empty?
       request_id = SecureRandom.uuid
       queue = Queue.new
 
@@ -126,7 +127,8 @@ module Copilot
     #
     # @param method [String]    the RPC method name
     # @param params [Hash, nil] optional parameters
-    def notify(method, params = nil)
+    def notify(method, params = nil, **kwargs)
+      params = kwargs if params.nil? && !kwargs.empty?
       send_message({
         jsonrpc: "2.0",
         method: method,

data/lib/copilot/sdk_protocol_version.rb

@@ -7,7 +7,7 @@
 module Copilot
   # The SDK protocol version.
   # This must match the version expected by the copilot-agent-runtime server.
-  SDK_PROTOCOL_VERSION = 2
+  SDK_PROTOCOL_VERSION = 3
 
   # @return [Integer] the SDK protocol version number
   def self.sdk_protocol_version

data/lib/copilot/session.rb

@@ -53,6 +53,11 @@ module Copilot
 
       @hooks      = nil
       @hooks_lock = Mutex.new
+
+      @exit_plan_mode_handler      = nil
+      @exit_plan_mode_handler_lock = Mutex.new
+
+      @trace_context_provider = nil
     end
 
     # Send a message to this session.
@@ -69,6 +74,22 @@ module Copilot
       payload[:mode] = mode if mode
       payload[:responseFormat] = response_format if response_format
       payload[:imageOptions] = image_options.to_h if image_options
+
+      # Inject trace context if provider is available
+      if @trace_context_provider
+        begin
+          tc = @trace_context_provider.call
+          if tc
+            tp = tc.respond_to?(:traceparent) ? tc.traceparent : tc[:traceparent]
+            ts = tc.respond_to?(:tracestate) ? tc.tracestate : tc[:tracestate]
+            payload[:traceparent] = tp if tp
+            payload[:tracestate] = ts if ts
+          end
+        rescue StandardError
+          # ignore trace context errors
+        end
+      end
+
       response = @rpc_client.request("session.send", payload)
       response["messageId"]
     end
@@ -202,6 +223,8 @@ module Copilot
       @permission_handler_lock.synchronize { @permission_handler = nil }
       @user_input_handler_lock.synchronize { @user_input_handler = nil }
       @hooks_lock.synchronize { @hooks = nil }
+      @exit_plan_mode_handler_lock.synchronize { @exit_plan_mode_handler = nil }
+      @trace_context_provider = nil
     end
 
     # Abort the currently processing message.
@@ -286,6 +309,32 @@ module Copilot
       @hooks_lock.synchronize { @hooks = hooks }
     end
 
+    # @api private
+    def _register_exit_plan_mode_handler(handler)
+      @exit_plan_mode_handler_lock.synchronize { @exit_plan_mode_handler = handler }
+    end
+
+    # @api private
+    def _handle_exit_plan_mode_request(params)
+      handler = @exit_plan_mode_handler_lock.synchronize { @exit_plan_mode_handler }
+      unless handler
+        return { approved: true }
+      end
+
+      begin
+        request = ExitPlanModeRequest.from_hash(params)
+        result = handler.call(request)
+        result.is_a?(ExitPlanModeResponse) ? result.to_h : result
+      rescue StandardError
+        { approved: true }
+      end
+    end
+
+    # @api private
+    def _register_trace_context_provider(provider)
+      @trace_context_provider = provider
+    end
+
     # @api private
     def _handle_hooks_invoke(hook_type, input_data)
       hooks = @hooks_lock.synchronize { @hooks }

data/lib/copilot/types.rb

@@ -75,6 +75,132 @@ module Copilot
     end
   end
 
+  # An action exposed by a canvas.
+  CanvasAction = Struct.new(:name, :description, :input_schema, keyword_init: true) do
+    def to_h
+      h = { name: name, description: description }
+      h[:inputSchema] = input_schema unless input_schema.nil?
+      h
+    end
+  end
+
+  # Declarative metadata for a canvas.
+  CanvasDeclaration = Struct.new(
+    :id, :display_name, :description, :input_schema, :actions,
+    keyword_init: true
+  ) do
+    def to_h
+      h = { id: id, displayName: display_name, description: description }
+      h[:inputSchema] = input_schema unless input_schema.nil?
+      h[:actions] = actions.map { |action| action.respond_to?(:to_h) ? action.to_h : action } unless actions.nil?
+      h
+    end
+  end
+
+  # Response returned when opening a canvas.
+  CanvasOpenResponse = Struct.new(:url, :title, :status, keyword_init: true) do
+    def to_h
+      h = {}
+      h[:url] = url if url
+      h[:title] = title if title
+      h[:status] = status if status
+      h
+    end
+  end
+
+  # Host capabilities passed to canvas callbacks.
+  CanvasHostCapabilities = Struct.new(:canvases, keyword_init: true) do
+    def self.from_hash(h)
+      h ||= {}
+      new(canvases: h.fetch("canvases", false))
+    end
+
+    def to_h
+      { canvases: !!canvases }
+    end
+  end
+
+  # Host context passed to canvas callbacks.
+  CanvasHostContext = Struct.new(:capabilities, keyword_init: true) do
+    def self.from_hash(h)
+      h ||= {}
+      new(capabilities: CanvasHostCapabilities.from_hash(h["capabilities"]))
+    end
+
+    def to_h
+      { capabilities: (capabilities || CanvasHostCapabilities.new(canvases: false)).to_h }
+    end
+  end
+
+  # Context provided when a canvas is opened.
+  CanvasOpenContext = Struct.new(
+    :session_id, :extension_id, :canvas_id, :instance_id, :input, :host,
+    keyword_init: true
+  ) do
+    def self.from_hash(h)
+      new(
+        session_id: h["sessionId"],
+        extension_id: h["extensionId"],
+        canvas_id: h["canvasId"],
+        instance_id: h["instanceId"],
+        input: h["input"],
+        host: h["host"] && CanvasHostContext.from_hash(h["host"])
+      )
+    end
+  end
+
+  # Context provided when a canvas action is invoked.
+  CanvasActionContext = Struct.new(
+    :session_id, :extension_id, :canvas_id, :instance_id, :action_name, :input, :host,
+    keyword_init: true
+  ) do
+    def self.from_hash(h)
+      new(
+        session_id: h["sessionId"],
+        extension_id: h["extensionId"],
+        canvas_id: h["canvasId"],
+        instance_id: h["instanceId"],
+        action_name: h["actionName"],
+        input: h["input"],
+        host: h["host"] && CanvasHostContext.from_hash(h["host"])
+      )
+    end
+  end
+
+  # Context provided for canvas lifecycle events.
+  CanvasLifecycleContext = Struct.new(
+    :session_id, :extension_id, :canvas_id, :instance_id, :host,
+    keyword_init: true
+  ) do
+    def self.from_hash(h)
+      new(
+        session_id: h["sessionId"],
+        extension_id: h["extensionId"],
+        canvas_id: h["canvasId"],
+        instance_id: h["instanceId"],
+        host: h["host"] && CanvasHostContext.from_hash(h["host"])
+      )
+    end
+  end
+
+  # GitHub repository metadata associated with a cloud session.
+  CloudSessionRepository = Struct.new(:owner, :name, :branch, keyword_init: true) do
+    def to_h
+      h = { owner: owner, name: name }
+      h[:branch] = branch if branch
+      h
+    end
+  end
+
+  # Cloud-session creation options.
+  CloudSessionOptions = Struct.new(:repository, keyword_init: true) do
+    def to_h
+      h = {}
+      h[:repository] = repository.respond_to?(:to_h) ? repository.to_h : repository if repository
+      h
+    end
+  end
+
   # System message in append mode (default).
   SystemMessageAppendConfig = Struct.new(:mode, :content, keyword_init: true) do
     def to_h
@@ -103,21 +229,23 @@ module Copilot
     SAFETY               = "safety"
     TOOL_INSTRUCTIONS    = "tool_instructions"
     CUSTOM_INSTRUCTIONS  = "custom_instructions"
+    RUNTIME_INSTRUCTIONS = "runtime_instructions"
     LAST_INSTRUCTIONS    = "last_instructions"
   end
 
   # Override action for a system prompt section.
   module SectionOverrideAction
-    REPLACE = "replace"
-    REMOVE  = "remove"
-    APPEND  = "append"
-    PREPEND = "prepend"
+    REPLACE   = "replace"
+    REMOVE    = "remove"
+    APPEND    = "append"
+    PREPEND   = "prepend"
+    TRANSFORM = "transform"
   end
 
   # Override operation for a single system prompt section.
-  SectionOverride = Struct.new(:action, :content, keyword_init: true) do
+  SectionOverride = Struct.new(:action, :content, :transform, keyword_init: true) do
     def to_h
-      h = { action: action }
+      h = { action: transform ? SectionOverrideAction::TRANSFORM : action }
       h[:content] = content if content
       h
     end
@@ -262,6 +390,69 @@ module Copilot
     end
   end
 
+  # Slash command input completion constants.
+  # Valid values: "directory"
+  module SlashCommandInputCompletion
+    DIRECTORY = "directory"
+  end
+
+  # Slash command kind constants.
+  # Valid values: "builtin", "client", "skill"
+  module SlashCommandKind
+    BUILTIN = "builtin"
+    CLIENT  = "client"
+    SKILL   = "skill"
+  end
+
+  # Input configuration for a slash command.
+  SlashCommandInput = Struct.new(:hint, :completion, keyword_init: true) do
+    def to_h
+      h = { hint: hint }
+      h[:completion] = completion if completion
+      h
+    end
+  end
+
+  # Information about a slash command.
+  SlashCommandInfo = Struct.new(
+    :allow_during_agent_execution, :description, :kind, :name,
+    :aliases, :experimental, :input,
+    keyword_init: true
+  ) do
+    def to_h
+      h = {
+        allowDuringAgentExecution: allow_during_agent_execution,
+        description: description,
+        kind: kind,
+        name: name,
+      }
+      h[:aliases] = aliases if aliases
+      h[:experimental] = experimental unless experimental.nil?
+      h[:input] = input.to_h if input
+      h
+    end
+  end
+
+  # Request to invoke a command.
+  CommandsInvokeRequest = Struct.new(:name, :input, keyword_init: true) do
+    def to_h
+      h = { name: name }
+      h[:input] = input if input
+      h
+    end
+  end
+
+  # Request to list available commands.
+  CommandsListRequest = Struct.new(:include_builtins, :include_client_commands, :include_skills, keyword_init: true) do
+    def to_h
+      h = {}
+      h[:includeBuiltins] = include_builtins unless include_builtins.nil?
+      h[:includeClientCommands] = include_client_commands unless include_client_commands.nil?
+      h[:includeSkills] = include_skills unless include_skills.nil?
+      h
+    end
+  end
+
   # Context for a slash-command invocation.
   CommandContext = Struct.new(:session_id, :command, :command_name, :args, keyword_init: true)
 
@@ -278,6 +469,30 @@ module Copilot
   # Result returned from an elicitation handler.
   ElicitationResult = Struct.new(:action, :content, keyword_init: true)
 
+  # Exit plan mode request from the server.
+  ExitPlanModeRequest = Struct.new(:session_id, keyword_init: true) do
+    def self.from_hash(h)
+      new(session_id: h["sessionId"])
+    end
+  end
+
+  # Exit plan mode response.
+  ExitPlanModeResponse = Struct.new(:approved, keyword_init: true) do
+    def to_h
+      { approved: approved }
+    end
+  end
+
+  # Trace context for distributed tracing.
+  TraceContext = Struct.new(:traceparent, :tracestate, keyword_init: true) do
+    def to_h
+      h = {}
+      h[:traceparent] = traceparent if traceparent
+      h[:tracestate] = tracestate if tracestate
+      h
+    end
+  end
+
   # Configuration for creating a session.
   SessionConfig = Struct.new(
     :session_id, :model, :reasoning_effort, :config_dir,
@@ -288,7 +503,7 @@ module Copilot
     :skill_directories, :disabled_skills, :infinite_sessions,
     :model_capabilities, :enable_config_discovery,
     :github_token,
-    :commands, :on_elicitation_request,
+    :commands, :on_elicitation_request, :on_exit_plan_mode,
     :instruction_directories,
     keyword_init: true
   )
@@ -303,14 +518,20 @@ module Copilot
     :skill_directories, :disabled_skills, :infinite_sessions,
     :model_capabilities, :enable_config_discovery,
     :github_token,
-    :commands, :on_elicitation_request,
+    :commands, :on_elicitation_request, :on_exit_plan_mode,
     :instruction_directories,
     :disable_resume,
     keyword_init: true
   )
 
   # Response format for message responses.
-  RESPONSE_FORMATS = %w[text image json_object].freeze
+  module ResponseFormat
+    TEXT = "text"
+    IMAGE = "image"
+    JSON_OBJECT = "json_object"
+  end
+
+  RESPONSE_FORMATS = [ResponseFormat::TEXT, ResponseFormat::IMAGE, ResponseFormat::JSON_OBJECT].freeze
 
   # Options for image generation.
   ImageOptions = Struct.new(:size, :quality, :style, keyword_init: true) do
@@ -414,10 +635,38 @@ module Copilot
     end
   end
 
+  # Model billing token prices.
+  ModelBillingTokenPrices = Struct.new(
+    :batch_size, :cache_price, :input_price, :output_price,
+    keyword_init: true
+  ) do
+    def self.from_hash(h)
+      new(
+        batch_size: h["batchSize"],
+        cache_price: h["cachePrice"],
+        input_price: h["inputPrice"],
+        output_price: h["outputPrice"]
+      )
+    end
+  end
+
+  # Model picker price category constants.
+  # Valid values: "high", "low", "medium", "very_high"
+  module ModelPickerPriceCategory
+    HIGH      = "high"
+    LOW       = "low"
+    MEDIUM    = "medium"
+    VERY_HIGH = "very_high"
+  end
+
   # Model billing information.
-  ModelBilling = Struct.new(:multiplier, keyword_init: true) do
+  ModelBilling = Struct.new(:multiplier, :token_prices, :picker_price_category, keyword_init: true) do
     def self.from_hash(h)
-      new(multiplier: h["multiplier"])
+      new(
+        multiplier: h["multiplier"],
+        token_prices: h["tokenPrices"] ? ModelBillingTokenPrices.from_hash(h["tokenPrices"]) : nil,
+        picker_price_category: h["pickerPriceCategory"]
+      )
     end
   end
 
@@ -544,6 +793,45 @@ module Copilot
     end
   end
 
+  # Experimental
+  # Diagnostics from loading skills.
+  SkillsLoadDiagnostics = Struct.new(:errors, :warnings, keyword_init: true) do
+    def self.from_hash(h)
+      new(
+        errors: h["errors"] || [],
+        warnings: h["warnings"] || []
+      )
+    end
+  end
+
+  # Per-session remote mode.
+  # "off" disables remote, "export" exports session events to Mission Control
+  # without enabling remote steering, "on" enables both export and remote steering.
+  module RemoteSessionMode
+    EXPORT = "export"
+    OFF    = "off"
+    ON     = "on"
+  end
+
+  # Experimental
+  # Request to enable remote mode for a session.
+  RemoteEnableRequest = Struct.new(:mode, keyword_init: true) do
+    def self.from_hash(h)
+      new(mode: h["mode"])
+    end
+  end
+
+  # Experimental
+  # Result of enabling remote mode for a session.
+  RemoteEnableResult = Struct.new(:remote_steerable, :url, keyword_init: true) do
+    def self.from_hash(h)
+      new(
+        remote_steerable: h["remoteSteerable"],
+        url: h["url"]
+      )
+    end
+  end
+
   # Foreground session info (TUI+server mode).
   ForegroundSessionInfo = Struct.new(:session_id, :workspace_path, keyword_init: true)
 
@@ -596,6 +884,7 @@ module Copilot
     :github_token, :use_logged_in_user, :session_idle_timeout_seconds,
     :session_fs,
     :copilot_home, :tcp_connection_token,
+    :on_get_trace_context,
     keyword_init: true
   )
 end

data/lib/copilot/version.rb

@@ -3,5 +3,5 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 
 module Copilot
-  VERSION = "2.0.0"
+  VERSION = "2.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: copilot-sdk-supercharged
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Jeremiah Isaacson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-04 00:00:00.000000000 Z
+date: 2026-05-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   A Ruby SDK for interacting with the GitHub Copilot CLI server via JSON-RPC 2.0.