Port upstream SDK changes: auth options, reasoning effort, user input handlers, hooks

Features ported from upstream copilot-sdk (87ff5510..a552ae4):

1. Authentication options (PR #237, #2fe7352):
   - Add githubToken and useLoggedInUser to CopilotClientOptions
   - Pass auth flags to CLI process on startup
   - Validate auth options with external server (CliUrl)

2. Reasoning effort support (PR #302, #c39a129):
   - Add reasoningEffort field to SessionConfig/ResumeSessionConfig
   - Add reasoningEffort boolean to ModelSupports
   - Add supportedReasoningEfforts and defaultReasoningEffort to ModelInfo

3. User input handler (PR #269, #2fa6a92):
   - Add UserInputRequest, UserInputResponse, UserInputHandler, UserInputInvocation
   - Add onUserInputRequest to SessionConfig and ResumeSessionConfig
   - Handle userInput.request RPC method in CopilotClient
   - Add registerUserInputHandler and handleUserInputRequest to CopilotSession

4. Hooks system (PR #269, #2fa6a92):
   - Add PreToolUseHookInput/Output, PostToolUseHookInput/Output
   - Add PreToolUseHandler, PostToolUseHandler functional interfaces
   - Add SessionHooks and HookInvocation classes
   - Handle hooks.invoke RPC method in CopilotClient
   - Add registerHooks and handleHooksInvoke to CopilotSession

5. Session config enhancements:
   - Add workingDirectory to SessionConfig and ResumeSessionConfig
   - Add disableResume to ResumeSessionConfig

6. Models caching (PR #300, #a552ae4):
   - Cache listModels() results to prevent rate limiting
   - Clear cache on disconnect

Author: brunoborges

.lastmerge

@@ -1 +1 @@
-87ff5510e0dacb030912501e4eb8deaac38f913f
+a552ae497313143e2426d6ff7e99b2632ab573dd

src/main/java/com/github/copilot/sdk/CopilotClient.java

@@ -89,6 +89,8 @@ public class CopilotClient implements AutoCloseable {
     private volatile boolean disposed = false;
     private final String optionsHost;
     private final Integer optionsPort;
+    private volatile List<ModelInfo> modelsCache;
+    private final Object modelsCacheLock = new Object();
 
     /**
      * Creates a new CopilotClient with default options.
@@ -114,6 +116,13 @@ public CopilotClient(CopilotClientOptions options) {
             throw new IllegalArgumentException("CliUrl is mutually exclusive with UseStdio and CliPath");
         }
 
+        // Validate auth options with external server
+        if (this.options.getCliUrl() != null && !this.options.getCliUrl().isEmpty()
+                && (this.options.getGithubToken() != null || this.options.getUseLoggedInUser() != null)) {
+            throw new IllegalArgumentException(
+                    "GithubToken and UseLoggedInUser cannot be used with CliUrl (external server manages its own auth)");
+        }
+
         // Parse CliUrl if provided
         if (this.options.getCliUrl() != null && !this.options.getCliUrl().isEmpty()) {
             URI uri = parseCliUrl(this.options.getCliUrl());
@@ -217,6 +226,16 @@ private void registerRpcHandlers(JsonRpcClient rpc) {
         rpc.registerMethodHandler("permission.request", (requestId, params) -> {
             handlePermissionRequest(rpc, requestId, params);
         });
+
+        // Handle user input requests
+        rpc.registerMethodHandler("userInput.request", (requestId, params) -> {
+            handleUserInputRequest(rpc, requestId, params);
+        });
+
+        // Handle hooks invocations
+        rpc.registerMethodHandler("hooks.invoke", (requestId, params) -> {
+            handleHooksInvoke(rpc, requestId, params);
+        });
     }
 
     private void handleToolCall(JsonRpcClient rpc, String requestId, JsonNode params) {
@@ -317,6 +336,93 @@ private void handlePermissionRequest(JsonRpcClient rpc, String requestId, JsonNo
         });
     }
 
+    private void handleUserInputRequest(JsonRpcClient rpc, String requestId, JsonNode params) {
+        CompletableFuture.runAsync(() -> {
+            try {
+                String sessionId = params.get("sessionId").asText();
+                String question = params.get("question").asText();
+                JsonNode choicesNode = params.get("choices");
+                JsonNode allowFreeformNode = params.get("allowFreeform");
+
+                CopilotSession session = sessions.get(sessionId);
+                if (session == null) {
+                    rpc.sendErrorResponse(Long.parseLong(requestId), -32602, "Unknown session " + sessionId);
+                    return;
+                }
+
+                com.github.copilot.sdk.json.UserInputRequest request = new com.github.copilot.sdk.json.UserInputRequest()
+                        .setQuestion(question);
+                if (choicesNode != null && choicesNode.isArray()) {
+                    List<String> choices = new ArrayList<>();
+                    for (JsonNode choice : choicesNode) {
+                        choices.add(choice.asText());
+                    }
+                    request.setChoices(choices);
+                }
+                if (allowFreeformNode != null) {
+                    request.setAllowFreeform(allowFreeformNode.asBoolean());
+                }
+
+                session.handleUserInputRequest(request).thenAccept(response -> {
+                    try {
+                        rpc.sendResponse(Long.parseLong(requestId),
+                                Map.of("answer", response.getAnswer(), "wasFreeform", response.isWasFreeform()));
+                    } catch (IOException e) {
+                        LOG.log(Level.SEVERE, "Error sending user input response", e);
+                    }
+                }).exceptionally(ex -> {
+                    try {
+                        rpc.sendErrorResponse(Long.parseLong(requestId), -32603,
+                                "User input handler error: " + ex.getMessage());
+                    } catch (IOException e) {
+                        LOG.log(Level.SEVERE, "Error sending user input error", e);
+                    }
+                    return null;
+                });
+            } catch (Exception e) {
+                LOG.log(Level.SEVERE, "Error handling user input request", e);
+            }
+        });
+    }
+
+    private void handleHooksInvoke(JsonRpcClient rpc, String requestId, JsonNode params) {
+        CompletableFuture.runAsync(() -> {
+            try {
+                String sessionId = params.get("sessionId").asText();
+                String hookType = params.get("hookType").asText();
+                JsonNode input = params.get("input");
+
+                CopilotSession session = sessions.get(sessionId);
+                if (session == null) {
+                    rpc.sendErrorResponse(Long.parseLong(requestId), -32602, "Unknown session " + sessionId);
+                    return;
+                }
+
+                session.handleHooksInvoke(hookType, input).thenAccept(output -> {
+                    try {
+                        if (output != null) {
+                            rpc.sendResponse(Long.parseLong(requestId), Map.of("output", output));
+                        } else {
+                            rpc.sendResponse(Long.parseLong(requestId), Map.of("output", (Object) null));
+                        }
+                    } catch (IOException e) {
+                        LOG.log(Level.SEVERE, "Error sending hooks response", e);
+                    }
+                }).exceptionally(ex -> {
+                    try {
+                        rpc.sendErrorResponse(Long.parseLong(requestId), -32603,
+                                "Hooks handler error: " + ex.getMessage());
+                    } catch (IOException e) {
+                        LOG.log(Level.SEVERE, "Error sending hooks error", e);
+                    }
+                    return null;
+                });
+            } catch (Exception e) {
+                LOG.log(Level.SEVERE, "Error handling hooks invoke", e);
+            }
+        });
+    }
+
     private void verifyProtocolVersion(Connection connection) throws Exception {
         int expectedVersion = SdkProtocolVersion.get();
         Map<String, Object> params = new HashMap<>();
@@ -373,6 +479,9 @@ private CompletableFuture<Void> cleanupConnection() {
         CompletableFuture<Connection> future = connectionFuture;
         connectionFuture = null;
 
+        // Clear models cache
+        modelsCache = null;
+
         if (future == null) {
             return CompletableFuture.completedFuture(null);
         }
@@ -414,6 +523,7 @@ public CompletableFuture<CopilotSession> createSession(SessionConfig config) {
             if (config != null) {
                 request.setModel(config.getModel());
                 request.setSessionId(config.getSessionId());
+                request.setReasoningEffort(config.getReasoningEffort());
                 request.setTools(config.getTools() != null
                         ? config.getTools().stream()
                                 .map(t -> new ToolDef(t.getName(), t.getDescription(), t.getParameters()))
@@ -424,6 +534,9 @@ public CompletableFuture<CopilotSession> createSession(SessionConfig config) {
                 request.setExcludedTools(config.getExcludedTools());
                 request.setProvider(config.getProvider());
                 request.setRequestPermission(config.getOnPermissionRequest() != null ? true : null);
+                request.setRequestUserInput(config.getOnUserInputRequest() != null ? true : null);
+                request.setHooks(config.getHooks() != null && config.getHooks().hasHooks() ? true : null);
+                request.setWorkingDirectory(config.getWorkingDirectory());
                 request.setStreaming(config.isStreaming() ? true : null);
                 request.setMcpServers(config.getMcpServers());
                 request.setCustomAgents(config.getCustomAgents());
@@ -442,6 +555,12 @@ public CompletableFuture<CopilotSession> createSession(SessionConfig config) {
                 if (config != null && config.getOnPermissionRequest() != null) {
                     session.registerPermissionHandler(config.getOnPermissionRequest());
                 }
+                if (config != null && config.getOnUserInputRequest() != null) {
+                    session.registerUserInputHandler(config.getOnUserInputRequest());
+                }
+                if (config != null && config.getHooks() != null) {
+                    session.registerHooks(config.getHooks());
+                }
                 sessions.put(response.getSessionId(), session);
                 return session;
             });
@@ -478,13 +597,18 @@ public CompletableFuture<CopilotSession> resumeSession(String sessionId, ResumeS
             ResumeSessionRequest request = new ResumeSessionRequest();
             request.setSessionId(sessionId);
             if (config != null) {
+                request.setReasoningEffort(config.getReasoningEffort());
                 request.setTools(config.getTools() != null
                         ? config.getTools().stream()
                                 .map(t -> new ToolDef(t.getName(), t.getDescription(), t.getParameters()))
                                 .collect(Collectors.toList())
                         : null);
                 request.setProvider(config.getProvider());
                 request.setRequestPermission(config.getOnPermissionRequest() != null ? true : null);
+                request.setRequestUserInput(config.getOnUserInputRequest() != null ? true : null);
+                request.setHooks(config.getHooks() != null && config.getHooks().hasHooks() ? true : null);
+                request.setWorkingDirectory(config.getWorkingDirectory());
+                request.setDisableResume(config.isDisableResume() ? true : null);
                 request.setStreaming(config.isStreaming() ? true : null);
                 request.setMcpServers(config.getMcpServers());
                 request.setCustomAgents(config.getCustomAgents());
@@ -501,6 +625,12 @@ public CompletableFuture<CopilotSession> resumeSession(String sessionId, ResumeS
                 if (config != null && config.getOnPermissionRequest() != null) {
                     session.registerPermissionHandler(config.getOnPermissionRequest());
                 }
+                if (config != null && config.getOnUserInputRequest() != null) {
+                    session.registerUserInputHandler(config.getOnUserInputRequest());
+                }
+                if (config != null && config.getHooks() != null) {
+                    session.registerHooks(config.getHooks());
+                }
                 sessions.put(response.getSessionId(), session);
                 return session;
             });
@@ -576,13 +706,36 @@ public CompletableFuture<GetAuthStatusResponse> getAuthStatus() {
 
     /**
      * Lists available models with their metadata.
+     * <p>
+     * Results are cached after the first successful call to avoid rate limiting.
+     * The cache is cleared when the client disconnects.
      *
      * @return a future that resolves with a list of available models
      * @see ModelInfo
      */
     public CompletableFuture<List<ModelInfo>> listModels() {
-        return ensureConnected().thenCompose(connection -> connection.rpc
-                .invoke("models.list", Map.of(), GetModelsResponse.class).thenApply(GetModelsResponse::getModels));
+        // Check cache first
+        List<ModelInfo> cached = modelsCache;
+        if (cached != null) {
+            return CompletableFuture.completedFuture(new ArrayList<>(cached));
+        }
+
+        return ensureConnected().thenCompose(connection -> {
+            // Double-check cache inside lock
+            synchronized (modelsCacheLock) {
+                if (modelsCache != null) {
+                    return CompletableFuture.completedFuture(new ArrayList<>(modelsCache));
+                }
+            }
+
+            return connection.rpc.invoke("models.list", Map.of(), GetModelsResponse.class).thenApply(response -> {
+                List<ModelInfo> models = response.getModels();
+                synchronized (modelsCacheLock) {
+                    modelsCache = models;
+                }
+                return new ArrayList<>(models); // Return a copy to prevent cache mutation
+            });
+        });
     }
 
     /**
@@ -668,6 +821,20 @@ private ProcessInfo startCliServer() throws IOException, InterruptedException {
             args.add(String.valueOf(options.getPort()));
         }
 
+        // Add auth-related flags
+        if (options.getGithubToken() != null && !options.getGithubToken().isEmpty()) {
+            args.add("--auth-token-env");
+            args.add("COPILOT_SDK_AUTH_TOKEN");
+        }
+
+        // Default UseLoggedInUser to false when GithubToken is provided
+        boolean useLoggedInUser = options.getUseLoggedInUser() != null
+                ? options.getUseLoggedInUser()
+                : (options.getGithubToken() == null || options.getGithubToken().isEmpty());
+        if (!useLoggedInUser) {
+            args.add("--no-auto-login");
+        }
+
         List<String> command = resolveCliCommand(cliPath, args);
 
         ProcessBuilder pb = new ProcessBuilder(command);
@@ -683,6 +850,11 @@ private ProcessInfo startCliServer() throws IOException, InterruptedException {
         }
         pb.environment().remove("NODE_DEBUG");
 
+        // Set auth token in environment if provided
+        if (options.getGithubToken() != null && !options.getGithubToken().isEmpty()) {
+            pb.environment().put("COPILOT_SDK_AUTH_TOKEN", options.getGithubToken());
+        }
+
         Process process = pb.start();
 
         // Forward stderr to logger in background