Add host-mediated GitHub API for extensions

Add a tokenless session.api.github.request surface for extensions that routes current-repository GitHub REST requests through the host runtime. The default API is GET-only, repository-relative, and includes client-side validation against arbitrary URLs or repository selection.

Regenerate Node and Rust RPC surfaces, add focused Node coverage for wire payloads and unsafe input rejection, and document the extension API contract.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: jchuerva

nodejs/docs/extensions.md

@@ -51,7 +51,29 @@ const session = await joinSession({
 });
 ```
 
-The `session` object provides methods for sending messages, logging to the timeline, listening to events, and accessing the RPC API. See the `.d.ts` files in the SDK package for full type information.
+The `session` object provides methods for sending messages, logging to the timeline, listening to events, and accessing host-mediated APIs. See the `.d.ts` files in the SDK package for full type information.
+
+## GitHub API requests
+
+Extensions can request GitHub REST data for the current session repository through `session.api.github.request(...)`:
+
+```js
+const alerts = await session.api.github.request({
+    method: "GET",
+    path: "/code-scanning/alerts",
+    query: { state: "open", per_page: 100 },
+    paginate: true,
+});
+```
+
+This API is tokenless from the extension's perspective. The extension sends a repository-relative path, and the host derives the current repository, selects the signed-in or project account, performs the authenticated request, and returns the response data. The extension does not receive a GitHub token.
+
+The default GitHub API surface is intentionally narrow:
+
+- Only `GET` requests are supported.
+- Paths must be repository-relative, such as `/code-scanning/alerts`.
+- Full URLs and `/repos/{owner}/{repo}/...` paths are rejected because the extension cannot choose an arbitrary repository.
+- Cross-repository, organization-wide, GraphQL, and write access are not part of the default API.
 
 ## Further Reading
 

nodejs/src/extension.ts

@@ -30,6 +30,13 @@ export type JoinSessionConfig = Omit<
 };
 
 export type { ExtensionInfo };
+export type {
+    GitHubApiQueryValue,
+    GitHubApiRequest,
+    GitHubApiRequestMethod,
+    GitHubApiResponse,
+    SessionApi,
+} from "./types.js";
 
 /**
  * Joins the current foreground session.

nodejs/src/generated/rpc.ts

@@ -76,6 +76,10 @@ export type {
     ForegroundSessionInfo,
     GetAuthStatusResponse,
     GetStatusResponse,
+    GitHubApiQueryValue,
+    GitHubApiRequest,
+    GitHubApiRequestMethod,
+    GitHubApiResponse,
     GitHubTelemetryNotification,
     GitHubTelemetryEvent,
     GitHubTelemetryClientInfo,
@@ -125,6 +129,7 @@ export type {
     SessionUpdatedEvent,
     SessionForegroundEvent,
     SessionBackgroundEvent,
+    SessionApi,
     SessionContext,
     SessionListFilter,
     SessionMetadata,

nodejs/src/index.ts

@@ -27,6 +27,8 @@ import type {
     ElicitationParams,
     ElicitationResult,
     ElicitationContext,
+    GitHubApiRequest,
+    GitHubApiResponse,
     ExitPlanModeHandler,
     ExitPlanModeRequest,
     ExitPlanModeResult,
@@ -48,6 +50,7 @@ import type {
     SessionEventPayload,
     SessionEventType,
     SessionHooks,
+    SessionApi,
     SessionUiApi,
     Tool,
     ToolHandler,
@@ -214,6 +217,18 @@ export class CopilotSession {
         };
     }
 
+    /**
+     * Host-mediated APIs for this session.
+     */
+    get api(): SessionApi {
+        return {
+            github: {
+                request: <T = unknown>(request: GitHubApiRequest) =>
+                    this._githubApiRequest<T>(request),
+            },
+        };
+    }
+
     /**
      * Sends a message to this session and waits for the response.
      *
@@ -1386,6 +1401,52 @@ export class CopilotSession {
     ): Promise<void> {
         await this.rpc.log({ message, ...options });
     }
+
+    private async _githubApiRequest<T = unknown>(
+        request: GitHubApiRequest
+    ): Promise<GitHubApiResponse<T>> {
+        validateGitHubApiRequest(request);
+        const response = await this.rpc.api.github.request({
+            scope: "current_repository",
+            method: "GET",
+            path: request.path,
+            query: request.query,
+            paginate: request.paginate,
+        });
+        return response as GitHubApiResponse<T>;
+    }
+}
+
+function validateGitHubApiRequest(request: GitHubApiRequest): void {
+    if (!request || typeof request !== "object") {
+        throw new Error("GitHub API request must be an object.");
+    }
+
+    if (request.method !== "GET") {
+        throw new Error("session.api.github.request currently supports only GET requests.");
+    }
+
+    if (typeof request.path !== "string" || request.path.length === 0) {
+        throw new Error("GitHub API request path must be a non-empty string.");
+    }
+
+    if (/^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(request.path)) {
+        throw new Error("GitHub API request path must be repository-relative, not a full URL.");
+    }
+
+    if (!request.path.startsWith("/") || request.path.startsWith("//")) {
+        throw new Error("GitHub API request path must start with a single `/`.");
+    }
+
+    if (/^\/repos\/[^/]+\/[^/]+(?:\/|$)/i.test(request.path)) {
+        throw new Error(
+            "GitHub API request path must not include `/repos/{owner}/{repo}`; the host derives the current repository."
+        );
+    }
+
+    if (request.path.split("/").includes("..")) {
+        throw new Error("GitHub API request path must not contain `..` segments.");
+    }
 }
 
 /**

nodejs/src/session.ts

@@ -17,6 +17,7 @@ import type {
 } from "./generated/session-events.js";
 import type { CopilotSession } from "./session.js";
 import type {
+    GitHubApiResponse as GeneratedGitHubApiResponse,
     GitHubTelemetryNotification,
     ModelBillingTokenPrices,
     OpenCanvasInstance,
@@ -838,6 +839,49 @@ export interface SessionUiApi {
     input(message: string, options?: UiInputOptions): Promise<string | null>;
 }
 
+export type GitHubApiRequestMethod = "GET";
+
+export type GitHubApiQueryValue =
+    | string
+    | number
+    | boolean
+    | null
+    | Array<string | number | boolean | null>;
+
+export interface GitHubApiRequest {
+    /** GitHub REST method. The initial API is read-only. */
+    method: GitHubApiRequestMethod;
+    /**
+     * Repository-relative REST path for the current session repository,
+     * for example `/code-scanning/alerts`.
+     */
+    path: string;
+    /** Query parameters for the GitHub REST request. */
+    query?: Record<string, GitHubApiQueryValue>;
+    /**
+     * Ask the host/runtime to follow GitHub REST pagination and return the combined data.
+     * Exact pagination limits and merge behavior are host-defined.
+     */
+    paginate?: boolean;
+}
+
+export type GitHubApiResponse<T = unknown> = Omit<GeneratedGitHubApiResponse, "data"> & {
+    data: T;
+};
+
+export interface SessionApi {
+    /** Tokenless, host-mediated APIs available to this session. */
+    github: {
+        /**
+         * Requests GitHub REST data for the current session repository through the host/runtime.
+         *
+         * The extension supplies a repository-relative path. The host/runtime derives the
+         * repository, performs authentication internally, and does not expose tokens.
+         */
+        request<T = unknown>(request: GitHubApiRequest): Promise<GitHubApiResponse<T>>;
+    };
+}
+
 export interface ToolCallRequestPayload {
     sessionId: string;
     toolCallId: string;

nodejs/src/types.ts

@@ -98,6 +98,67 @@ describe("CopilotClient", () => {
         });
     });
 
+    it("sends current-repository GitHub API requests through session RPC", async () => {
+        const sendRequest = vi.fn(async () => ({
+            status: 200,
+            headers: { "x-github-request-id": "request-1" },
+            data: [{ number: 1 }],
+        }));
+        const session = new CopilotSession("session-1", { sendRequest } as any);
+
+        const result = await session.api.github.request<Array<{ number: number }>>({
+            method: "GET",
+            path: "/code-scanning/alerts",
+            query: { state: "open", per_page: 100 },
+            paginate: true,
+        });
+
+        expect(sendRequest).toHaveBeenCalledWith("session.api.github.request", {
+            sessionId: "session-1",
+            scope: "current_repository",
+            method: "GET",
+            path: "/code-scanning/alerts",
+            query: { state: "open", per_page: 100 },
+            paginate: true,
+        });
+        expect(result.data[0]?.number).toBe(1);
+    });
+
+    it.each([
+        ["non-GET method", { method: "POST", path: "/code-scanning/alerts" }],
+        ["empty path", { method: "GET", path: "" }],
+        ["path without leading slash", { method: "GET", path: "code-scanning/alerts" }],
+        ["full URL", { method: "GET", path: "https://api.github.com/repos/github/copilot-sdk" }],
+        [
+            "protocol-relative URL",
+            { method: "GET", path: "//api.github.com/repos/github/copilot-sdk" },
+        ],
+        [
+            "explicit repo scope",
+            { method: "GET", path: "/repos/github/copilot-sdk/code-scanning/alerts" },
+        ],
+        ["traversal segment", { method: "GET", path: "/code-scanning/../alerts" }],
+    ])("rejects unsafe GitHub API request input: %s", async (_name, request) => {
+        const sendRequest = vi.fn();
+        const session = new CopilotSession("session-1", { sendRequest } as any);
+
+        await expect(session.api.github.request(request as any)).rejects.toThrow();
+        expect(sendRequest).not.toHaveBeenCalled();
+    });
+
+    it("rejects PATCH GitHub API requests before dispatch", async () => {
+        const sendRequest = vi.fn();
+        const session = new CopilotSession("session-1", { sendRequest } as any);
+
+        await expect(
+            session.api.github.request({
+                method: "PATCH",
+                path: "/code-scanning/alerts/1",
+            } as any)
+        ).rejects.toThrow("session.api.github.request currently supports only GET requests.");
+        expect(sendRequest).not.toHaveBeenCalled();
+    });
+
     it("passes MCP OAuth requests through when optional metadata is absent", async () => {
         let observedRequest: any;
         const session = new CopilotSession(