copilot-sdk-supercharged 2.2.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c36a15eb69c732f5661c54325b83a2b10337a45e271bc3df776b0069514cbb0
-  data.tar.gz: fbcc9e01930bf0d7995295ffc0b1895d4f2afbae01367f258811f3d197d1f209
+  metadata.gz: 8d80c4e262952967db3b9ed58e8899587afa12b158074ab57d7f475af58ccd68
+  data.tar.gz: 302abe246cec1dd679f2036f49407a10b01756c421634a3c97f6fb1105743606
 SHA512:
-  metadata.gz: '06917253b38db497246957e4e69aa7551f92cb25c3306a318dda3f34b87a586db33e864c04b23615b29f264cc23ac87b7e13e51a599db96a156c3b9c6b9f3b37'
-  data.tar.gz: 368a57e037e6c5a9f570c6f6e2704a8b5cf2f4c5ca228c75c2d09e605a528ab793216b4f26864b5807cb6c480e87eec8f2c6bc5653b58eceb2a2caa606d0e85a
+  metadata.gz: e7aa7ee115dfe39db890cffa6d1d4535caf0b6926cde80b0346b5ce3e8e5a9ca24b688af91c49b223aa5fbdb1e95733052f142b4bcef42d18d69101ccae1fde5
+  data.tar.gz: f51f8baeb7ede5fb5db28855db3e94f397379e78d75e9f6aa871a6c970733b8bfd80ab5d3013acc21510add30f29be55e7db79cb6251061355470b220e95655a

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]
@@ -812,6 +845,23 @@ module Copilot
         payload[:infiniteSessions] = is_cfg.respond_to?(:to_wire) ? is_cfg.to_wire : is_cfg
       end
 
+      # --- Upstream-sync session options (parity with @github/copilot-sdk) ---
+      payload[:enableCitations] = config[:enable_citations] unless config[:enable_citations].nil?
+      payload[:excludedBuiltinAgents] = config[:excluded_builtin_agents] if config[:excluded_builtin_agents]
+      if config[:session_limits]
+        sl = config[:session_limits]
+        payload[:sessionLimits] = sl.respond_to?(:to_wire) ? sl.to_wire : sl
+      end
+      if config[:memory]
+        mem = config[:memory]
+        payload[:memory] = mem.respond_to?(:to_wire) ? mem.to_wire : mem
+      end
+      payload[:otlpProtocol] = config[:otlp_protocol] if config[:otlp_protocol]
+      payload[:enableWebSocketResponses] = config[:enable_web_socket_responses] unless config[:enable_web_socket_responses].nil?
+      payload[:expAssignments] = config[:exp_assignments] if config[:exp_assignments]
+      # MCP OAuth host token handler: signal to the runtime that a handler is registered.
+      payload[:mcpAuthHandler] = true if config[:on_mcp_auth_request]
+
       payload
     end
 

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/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.
@@ -63,12 +68,31 @@ module Copilot
     # @param response_format [String, nil]       desired response format ("text", "image", "json_object")
     # @param image_options   [ImageOptions, nil] options for image generation
     # @return [String] the message ID
-    def send(prompt:, attachments: nil, mode: nil, response_format: nil, image_options: nil)
+    def send(prompt:, attachments: nil, mode: nil, agent_mode: nil, display_prompt: nil, request_headers: nil, response_format: nil, image_options: nil)
       payload = { sessionId: @session_id, prompt: prompt }
       payload[:attachments] = attachments if attachments
       payload[:mode] = mode if mode
+      payload[:agentMode] = agent_mode if agent_mode
+      payload[:displayPrompt] = display_prompt if display_prompt
+      payload[:requestHeaders] = request_headers if request_headers
       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
@@ -87,7 +111,7 @@ module Copilot
     # @return [SessionEvent, nil] the final assistant.message event, or nil
     # @raise [Timeout::Error] if the timeout expires before session.idle
     # @raise [RuntimeError] if the session emits a session.error event
-    def send_and_wait(prompt:, attachments: nil, mode: nil, response_format: nil, image_options: nil, timeout: 60)
+    def send_and_wait(prompt:, attachments: nil, mode: nil, agent_mode: nil, display_prompt: nil, request_headers: nil, response_format: nil, image_options: nil, timeout: 60)
       idle_mutex = Mutex.new
       idle_cv    = ConditionVariable.new
       idle_fired = false
@@ -118,6 +142,8 @@ module Copilot
 
       begin
         self.send(prompt: prompt, attachments: attachments, mode: mode,
+                  agent_mode: agent_mode, display_prompt: display_prompt,
+                  request_headers: request_headers,
                   response_format: response_format, image_options: image_options)
 
         idle_mutex.synchronize do
@@ -202,6 +228,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 +314,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

@@ -596,6 +596,67 @@ module Copilot
     :github_token, :use_logged_in_user, :session_idle_timeout_seconds,
     :session_fs,
     :copilot_home, :tcp_connection_token,
+    :request_handler,
     keyword_init: true
   )
+
+  # --- Upstream-sync feature types (parity with @github/copilot-sdk) ---
+
+  # Per-session AI-credit budget; set +max_ai_credits+ to cap spend.
+  SessionLimitsConfig = Struct.new(:max_ai_credits, keyword_init: true) do
+    def to_wire
+      { maxAiCredits: max_ai_credits }.compact
+    end
+  end
+
+  # Opt-in persistent session memory.
+  MemoryConfiguration = Struct.new(:enabled, keyword_init: true) do
+    def to_wire
+      { enabled: enabled }.compact
+    end
+  end
+
+  # Arguments passed to a BYOK +bearer_token_provider+ callable (per-session scoping).
+  ProviderTokenArgs = Struct.new(:session_id, keyword_init: true)
+
+  # Intercept outbound LLM inference HTTP/WebSocket requests. Assign an instance to
+  # +ClientOptions#request_handler+ and override +send_request+ to mutate, replace,
+  # or forward the request. BYOK providers may also set +bearer_token_provider+.
+  class CopilotRequestHandler
+    def send_request(request, _context)
+      request
+    end
+  end
+
+  # Tool "defer" loading policy: eager pre-load ("never") or lazy via search ("auto").
+  module ToolDefer
+    AUTO  = "auto"
+    NEVER = "never"
+  end
+
+  # System-message section identifiers (used with system_message section overrides).
+  # The "preamble" section targets only the identity preamble; the "preserve" action
+  # protects an individually-addressable section from a group-level remove.
+  module SystemMessageSection
+    PREAMBLE          = "preamble"
+    IDENTITY          = "identity"
+    TOOL_INSTRUCTIONS = "tool_instructions"
+    PRESERVE          = "preserve"
+  end
+
+  # Hook names include :on_pre_tool_use, :on_post_tool_use, :on_pre_mcp_tool_call,
+  # and :on_mcp_auth_request (MCP OAuth host token handler).
+
+  # GitHub-anchored attachment variants.
+  module GitHubAttachment
+    GITHUB_COMMIT          = "GitHubCommit"
+    GITHUB_RELEASE         = "GitHubRelease"
+    GITHUB_ACTIONS_JOB     = "GitHubActionsJob"
+    GITHUB_REPOSITORY      = "GitHubRepository"
+    GITHUB_FILE_DIFF       = "GitHubFileDiff"
+    GITHUB_TREE_COMPARISON = "GitHubTreeComparison"
+    GITHUB_URL             = "GitHubUrl"
+    GITHUB_FILE            = "GitHubFile"
+    GITHUB_SNIPPET         = "GitHubSnippet"
+  end
 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.1.0"
 end

metadata

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