Chunk 3: Wire generated RPC wrappers into CopilotClient and CopilotSession

Copilot · edburns · web-flow · commit a2712a74247a · 2026-04-16T19:21:04.000Z
Agent-Logs-Url: https://github.com/github/copilot-sdk-java/sessions/77121eb8-79b7-46ee-8734-81054d4e19bf Co-authored-by: edburns <75821+edburns@users.noreply.github.com>
diff --git a/src/main/java/com/github/copilot/sdk/CopilotClient.java b/src/main/java/com/github/copilot/sdk/CopilotClient.java
@@ -21,6 +21,7 @@
 
 import com.github.copilot.sdk.json.CopilotClientOptions;
 import com.github.copilot.sdk.json.CreateSessionResponse;
+import com.github.copilot.sdk.generated.rpc.ServerRpc;
 import com.github.copilot.sdk.json.DeleteSessionResponse;
 import com.github.copilot.sdk.json.GetAuthStatusResponse;
 import com.github.copilot.sdk.json.GetLastSessionIdResponse;
@@ -179,7 +180,7 @@ private Connection startCoreBody() {
                         processInfo.port());
             }
 
-            Connection connection = new Connection(rpc, process);
+            Connection connection = new Connection(rpc, process, new ServerRpc(rpc::invoke));
 
             // Register handlers for server-to-client calls
             RpcHandlerDispatcher dispatcher = new RpcHandlerDispatcher(sessions, lifecycleManager::dispatch,
@@ -478,6 +479,32 @@ public ConnectionState getState() {
         return ConnectionState.CONNECTED;
     }
 
+    /**
+     * Returns the typed RPC client for server-level methods.
+     * <p>
+     * Provides strongly-typed access to all server-level API namespaces such as
+     * {@code models}, {@code tools}, {@code account}, and {@code mcp}.
+     * <p>
+     * Example usage:
+     *
+     * <pre>{@code
+     * client.start().get();
+     * var models = client.getRpc().models.list().get();
+     * }</pre>
+     *
+     * @return the server-level typed RPC client
+     * @throws IllegalStateException
+     *             if the client is not connected; call {@link #start()} first
+     * @since 1.0.0
+     */
+    public ServerRpc getRpc() {
+        CompletableFuture<Connection> future = connectionFuture;
+        if (future == null || !future.isDone() || future.isCompletedExceptionally()) {
+            throw new IllegalStateException("Client not connected; call start() first");
+        }
+        return future.join().serverRpc();
+    }
+
     /**
      * Pings the server to check connectivity.
      * <p>
@@ -795,7 +822,7 @@ public void close() {
         }
     }
 
-    private static record Connection(JsonRpcClient rpc, Process process) {
+    private static record Connection(JsonRpcClient rpc, Process process, ServerRpc serverRpc) {
     };
 
 }
diff --git a/src/main/java/com/github/copilot/sdk/CopilotSession.java b/src/main/java/com/github/copilot/sdk/CopilotSession.java
@@ -30,6 +30,9 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.github.copilot.sdk.generated.AssistantMessageEvent;
+import com.github.copilot.sdk.generated.rpc.SessionCommandsHandlePendingCommandParams;
+import com.github.copilot.sdk.generated.rpc.SessionPermissionsHandlePendingPermissionRequestParams;
+import com.github.copilot.sdk.generated.rpc.SessionRpc;
 import com.github.copilot.sdk.generated.CapabilitiesChangedEvent;
 import com.github.copilot.sdk.generated.CommandExecuteEvent;
 import com.github.copilot.sdk.generated.ElicitationRequestedEvent;
@@ -134,6 +137,7 @@ public final class CopilotSession implements AutoCloseable {
     private volatile SessionCapabilities capabilities = new SessionCapabilities();
     private final SessionUiApi ui;
     private final JsonRpcClient rpc;
+    private volatile SessionRpc sessionRpc;
     private final Set<Consumer<SessionEvent>> eventHandlers = ConcurrentHashMap.newKeySet();
     private final Map<String, ToolDefinition> toolHandlers = new ConcurrentHashMap<>();
     private final Map<String, CommandHandler> commandHandlers = new ConcurrentHashMap<>();
@@ -183,6 +187,7 @@ public final class CopilotSession implements AutoCloseable {
         this.rpc = rpc;
         this.workspacePath = workspacePath;
         this.ui = new SessionUiApiImpl();
+        this.sessionRpc = rpc != null ? new SessionRpc(rpc::invoke, sessionId) : null;
         var executor = new ScheduledThreadPoolExecutor(1, r -> {
             var t = new Thread(r, "sendAndWait-timeout");
             t.setDaemon(true);
@@ -219,6 +224,7 @@ public String getSessionId() {
      */
     void setActiveSessionId(String sessionId) {
         this.sessionId = sessionId;
+        this.sessionRpc = rpc != null ? new SessionRpc(rpc::invoke, sessionId) : null;
     }
 
     /**
@@ -269,6 +275,25 @@ public SessionUiApi getUi() {
         return ui;
     }
 
+    /**
+     * Returns the typed RPC client for this session.
+     * <p>
+     * Provides strongly-typed access to all session-level API namespaces. The
+     * {@code sessionId} is injected automatically into every call.
+     * <p>
+     * Example usage:
+     *
+     * <pre>{@code
+     * var agents = session.getRpc().agent.list().get();
+     * }</pre>
+     *
+     * @return the session-scoped typed RPC client
+     * @since 1.0.0
+     */
+    public SessionRpc getRpc() {
+        return sessionRpc;
+    }
+
     /**
      * Sets a custom error handler for exceptions thrown by event handlers.
      * <p>
@@ -851,8 +876,9 @@ private void executePermissionAndRespondAsync(String requestId, PermissionReques
                     try {
                         PermissionRequestResult denied = new PermissionRequestResult();
                         denied.setKind(PermissionRequestResultKind.DENIED_COULD_NOT_REQUEST_FROM_USER);
-                        rpc.invoke("session.permissions.handlePendingPermissionRequest",
-                                Map.of("sessionId", sessionId, "requestId", requestId, "result", denied), Object.class);
+                        sessionRpc.permissions.handlePendingPermissionRequest(
+                                new SessionPermissionsHandlePendingPermissionRequestParams(sessionId, requestId,
+                                        denied));
                     } catch (Exception e) {
                         LOG.log(Level.WARNING, "Error sending permission denied for requestId=" + requestId, e);
                     }
@@ -863,8 +889,8 @@ private void executePermissionAndRespondAsync(String requestId, PermissionReques
                 try {
                     PermissionRequestResult denied = new PermissionRequestResult();
                     denied.setKind(PermissionRequestResultKind.DENIED_COULD_NOT_REQUEST_FROM_USER);
-                    rpc.invoke("session.permissions.handlePendingPermissionRequest",
-                            Map.of("sessionId", sessionId, "requestId", requestId, "result", denied), Object.class);
+                    sessionRpc.permissions.handlePendingPermissionRequest(
+                            new SessionPermissionsHandlePendingPermissionRequestParams(sessionId, requestId, denied));
                 } catch (Exception sendEx) {
                     LOG.log(Level.WARNING, "Error sending permission denied for requestId=" + requestId, sendEx);
                 }
@@ -908,8 +934,8 @@ private void executeCommandAndRespondAsync(String requestId, String commandName,
         Runnable task = () -> {
             if (handler == null) {
                 try {
-                    rpc.invoke("session.commands.handlePendingCommand", Map.of("sessionId", sessionId, "requestId",
-                            requestId, "error", "Unknown command: " + commandName), Object.class);
+                    sessionRpc.commands.handlePendingCommand(new SessionCommandsHandlePendingCommandParams(sessionId,
+                            requestId, "Unknown command: " + commandName));
                 } catch (Exception e) {
                     LOG.log(Level.WARNING, "Error sending command error for requestId=" + requestId, e);
                 }
@@ -920,16 +946,16 @@ private void executeCommandAndRespondAsync(String requestId, String commandName,
                         .setArgs(args);
                 handler.handle(ctx).thenRun(() -> {
                     try {
-                        rpc.invoke("session.commands.handlePendingCommand",
-                                Map.of("sessionId", sessionId, "requestId", requestId), Object.class);
+                        sessionRpc.commands.handlePendingCommand(
+                                new SessionCommandsHandlePendingCommandParams(sessionId, requestId, null));
                     } catch (Exception e) {
                         LOG.log(Level.WARNING, "Error sending command result for requestId=" + requestId, e);
                     }
                 }).exceptionally(ex -> {
                     try {
                         String msg = ex.getMessage() != null ? ex.getMessage() : ex.toString();
-                        rpc.invoke("session.commands.handlePendingCommand",
-                                Map.of("sessionId", sessionId, "requestId", requestId, "error", msg), Object.class);
+                        sessionRpc.commands.handlePendingCommand(
+                                new SessionCommandsHandlePendingCommandParams(sessionId, requestId, msg));
                     } catch (Exception e) {
                         LOG.log(Level.WARNING, "Error sending command error for requestId=" + requestId, e);
                     }
@@ -939,8 +965,8 @@ private void executeCommandAndRespondAsync(String requestId, String commandName,
                 LOG.log(Level.WARNING, "Error executing command for requestId=" + requestId, e);
                 try {
                     String msg = e.getMessage() != null ? e.getMessage() : e.toString();
-                    rpc.invoke("session.commands.handlePendingCommand",
-                            Map.of("sessionId", sessionId, "requestId", requestId, "error", msg), Object.class);
+                    sessionRpc.commands.handlePendingCommand(
+                            new SessionCommandsHandlePendingCommandParams(sessionId, requestId, msg));
                 } catch (Exception sendEx) {
                     LOG.log(Level.WARNING, "Error sending command error for requestId=" + requestId, sendEx);
                 }
diff --git a/src/test/java/com/github/copilot/sdk/CopilotSessionTest.java b/src/test/java/com/github/copilot/sdk/CopilotSessionTest.java
@@ -29,6 +29,7 @@
 import com.github.copilot.sdk.generated.SessionStartEvent;
 import com.github.copilot.sdk.generated.ToolExecutionStartEvent;
 import com.github.copilot.sdk.generated.UserMessageEvent;
+import com.github.copilot.sdk.generated.rpc.SessionRpc;
 import com.github.copilot.sdk.json.MessageOptions;
 import com.github.copilot.sdk.json.PermissionHandler;
 import com.github.copilot.sdk.json.ResumeSessionConfig;
@@ -849,4 +850,30 @@ void testShouldGetSessionMetadataById() throws Exception {
             session.close();
         }
     }
+
+    /**
+     * Verifies that {@link CopilotSession#getRpc()} returns a non-null
+     * {@link SessionRpc} wired to the session's ID and that all namespace fields
+     * are present.
+     */
+    @Test
+    void testGetRpcReturnsSessionRpcWithCorrectSessionId() throws Exception {
+        ctx.configureForTest("session", "should_receive_session_events");
+
+        try (CopilotClient client = ctx.createClient()) {
+            CopilotSession session = client
+                    .createSession(new SessionConfig().setOnPermissionRequest(PermissionHandler.APPROVE_ALL)).get();
+
+            SessionRpc rpc = session.getRpc();
+            assertNotNull(rpc, "getRpc() must not return null");
+            assertNotNull(rpc.agent, "SessionRpc.agent must not be null");
+            assertNotNull(rpc.model, "SessionRpc.model must not be null");
+            assertNotNull(rpc.tools, "SessionRpc.tools must not be null");
+            assertNotNull(rpc.permissions, "SessionRpc.permissions must not be null");
+            assertNotNull(rpc.commands, "SessionRpc.commands must not be null");
+            assertNotNull(rpc.ui, "SessionRpc.ui must not be null");
+
+            session.close();
+        }
+    }
 }
diff --git a/src/test/java/com/github/copilot/sdk/RpcWrappersTest.java b/src/test/java/com/github/copilot/sdk/RpcWrappersTest.java
@@ -14,6 +14,7 @@
 
 import org.junit.jupiter.api.Test;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.github.copilot.sdk.generated.rpc.McpConfigAddParams;
 import com.github.copilot.sdk.generated.rpc.McpDiscoverParams;
 import com.github.copilot.sdk.generated.rpc.RpcCaller;
@@ -273,4 +274,151 @@ void serverRpc_account_getQuota_invokes_correct_method() {
         assertEquals(1, stub.calls.size());
         assertEquals("account.getQuota", stub.calls.get(0).method());
     }
+
+    // ── CopilotSession.getRpc() wiring tests ──────────────────────────────────
+    // These tests use a socket-pair backed JsonRpcClient (same pattern as
+    // RpcHandlerDispatcherTest) to construct a real CopilotSession and verify
+    // that getRpc() returns a correctly wired SessionRpc.
+
+    @Test
+    void copilotSession_getRpc_returns_non_null_session_rpc() throws Exception {
+        try (var sockets = new SocketPair()) {
+            var rpc = sockets.client();
+            var session = new CopilotSession("sess-unit", rpc);
+
+            assertNotNull(session.getRpc());
+        }
+    }
+
+    @Test
+    void copilotSession_getRpc_sessionId_matches_session() throws Exception {
+        try (var sockets = new SocketPair()) {
+            var rpc = sockets.client();
+            var stub = sockets.stubServer();
+            var session = new CopilotSession("sess-test-id", rpc);
+
+            // Call any no-arg session method via getRpc() to verify sessionId injection
+            session.getRpc().agent.list();
+
+            // Drain the sent message from the stub server
+            var sent = stub.readOneMessage();
+            assertEquals("session.agent.list", sent.get("method").asText());
+            assertEquals("sess-test-id", sent.get("params").get("sessionId").asText());
+        }
+    }
+
+    @Test
+    void copilotSession_getRpc_updates_when_sessionId_changes() throws Exception {
+        try (var sockets = new SocketPair()) {
+            var rpc = sockets.client();
+            var stub = sockets.stubServer();
+            var session = new CopilotSession("old-id", rpc);
+
+            // Simulate server returning a different sessionId (v2 CLI behaviour)
+            session.setActiveSessionId("new-id");
+
+            session.getRpc().agent.list();
+
+            var sent = stub.readOneMessage();
+            assertEquals("new-id", sent.get("params").get("sessionId").asText(),
+                    "getRpc() should reflect the updated sessionId");
+        }
+    }
+
+    @Test
+    void copilotSession_getRpc_all_namespace_fields_present() throws Exception {
+        try (var sockets = new SocketPair()) {
+            var rpc = sockets.client();
+            var session = new CopilotSession("sess-ns", rpc);
+
+            var sessionRpc = session.getRpc();
+            assertNotNull(sessionRpc.model);
+            assertNotNull(sessionRpc.agent);
+            assertNotNull(sessionRpc.skills);
+            assertNotNull(sessionRpc.tools);
+            assertNotNull(sessionRpc.permissions);
+            assertNotNull(sessionRpc.commands);
+            assertNotNull(sessionRpc.ui);
+        }
+    }
+
+    /**
+     * Helper that creates a loopback socket pair. The client side is used by
+     * {@link JsonRpcClient}; the server side can be read to inspect outbound
+     * messages.
+     */
+    private static final class SocketPair implements AutoCloseable {
+
+        private static final ObjectMapper MAPPER = JsonRpcClient.getObjectMapper();
+
+        private final java.net.Socket clientSocket;
+        private final java.net.Socket serverSocket;
+        private final JsonRpcClient rpcClient;
+
+        SocketPair() throws Exception {
+            try (var ss = new java.net.ServerSocket(0)) {
+                clientSocket = new java.net.Socket("localhost", ss.getLocalPort());
+                serverSocket = ss.accept();
+            }
+            serverSocket.setSoTimeout(3000);
+            rpcClient = JsonRpcClient.fromSocket(clientSocket);
+        }
+
+        JsonRpcClient client() {
+            return rpcClient;
+        }
+
+        StubServer stubServer() {
+            return new StubServer(serverSocket);
+        }
+
+        @Override
+        public void close() throws Exception {
+            rpcClient.close();
+            clientSocket.close();
+            serverSocket.close();
+        }
+    }
+
+    /**
+     * Reads raw JSON-RPC messages written to the server side of the socket.
+     */
+    private static final class StubServer {
+
+        private static final ObjectMapper MAPPER = JsonRpcClient.getObjectMapper();
+
+        private final java.io.InputStream in;
+
+        StubServer(java.net.Socket socket) {
+            try {
+                this.in = socket.getInputStream();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        /**
+         * Reads one JSON-RPC message (Content-Length framed) from the stream.
+         */
+        com.fasterxml.jackson.databind.JsonNode readOneMessage() throws Exception {
+            // Read Content-Length header
+            var header = new StringBuilder();
+            int b;
+            while ((b = in.read()) != -1) {
+                if (b == '\n' && header.toString().endsWith("\r")) {
+                    break;
+                }
+                header.append((char) b);
+            }
+            // Skip blank line
+            in.read(); // '\r'
+            in.read(); // '\n'
+
+            String hdr = header.toString().trim();
+            int colon = hdr.indexOf(':');
+            int len = Integer.parseInt(hdr.substring(colon + 1).trim());
+            byte[] body = in.readNBytes(len);
+            return MAPPER.readTree(body);
+        }
+    }
 }
