@github/copilot-sdk 1.0.2 → 1.0.4

package/dist/generated/rpc.js

@@ -36,7 +36,35 @@ function createServerRpc(connection) {
        *
        * @returns Quota usage snapshots for the resolved user, keyed by quota type.
        */
-      getQuota: async (params) => connection.sendRequest("account.getQuota", params)
+      getQuota: async (params) => connection.sendRequest("account.getQuota", params),
+      /**
+       * Gets the currently active authentication credentials from the global auth manager.
+       *
+       * @returns Current authentication state
+       */
+      getCurrentAuth: async () => connection.sendRequest("account.getCurrentAuth", {}),
+      /**
+       * Gets all authenticated users available for account switching.
+       *
+       * @returns List of all authenticated users
+       */
+      getAllUsers: async () => connection.sendRequest("account.getAllUsers", {}),
+      /**
+       * Stores authentication credentials after successful login (e.g., device code flow).
+       *
+       * @param params Credentials to store after successful authentication
+       *
+       * @returns Result of a successful login; throws on failure
+       */
+      login: async (params) => connection.sendRequest("account.login", params),
+      /**
+       * Removes user authentication from keychain and persisted state.
+       *
+       * @param params User to log out
+       *
+       * @returns Logout result indicating if more users remain
+       */
+      logout: async (params) => connection.sendRequest("account.logout", params)
     },
     secrets: {
       /**
@@ -281,6 +309,31 @@ function createServerRpc(connection) {
       setProvider: async (params) => connection.sendRequest("sessionFs.setProvider", params)
     },
     /** @experimental */
+    llmInference: {
+      /**
+       * Registers an SDK client as the LLM inference callback provider.
+       *
+       * @returns Indicates whether the calling client was registered as the LLM inference provider.
+       */
+      setProvider: async () => connection.sendRequest("llmInference.setProvider", {}),
+      /**
+       * Delivers the response head (status + headers) for an in-flight request, correlated by the requestId the runtime supplied in httpRequestStart. Must be called exactly once per request before any httpResponseChunk frames.
+       *
+       * @param params Response head.
+       *
+       * @returns Whether the start frame was accepted.
+       */
+      httpResponseStart: async (params) => connection.sendRequest("llmInference.httpResponseStart", params),
+      /**
+       * Delivers a body byte range (or a terminal transport error) for an in-flight response, correlated by requestId. Set `end` true on the last chunk. When `error` is set the response terminates with a transport-level failure and the runtime raises an APIConnectionError.
+       *
+       * @param params A response body chunk or terminal error.
+       *
+       * @returns Whether the chunk was accepted.
+       */
+      httpResponseChunk: async (params) => connection.sendRequest("llmInference.httpResponseChunk", params)
+    },
+    /** @experimental */
     sessions: {
       /**
        * Creates or resumes a local session and returns the opened session ID.
@@ -1040,10 +1093,18 @@ function createSessionRpc(connection, sessionId) {
       isServerRunning: async (params) => connection.sendRequest("session.mcp.isServerRunning", { sessionId, ...params }),
       /** @experimental */
       oauth: {
+        /**
+         * Resolves a pending MCP OAuth request with a host-provided token or cancellation. The pending request is emitted as mcp.oauth_required with the data necessary to authorize the request.
+         *
+         * @param params Pending MCP OAuth request ID and host-provided token or cancellation response.
+         *
+         * @returns Indicates whether the pending MCP OAuth response was accepted.
+         */
+        handlePendingRequest: async (params) => connection.sendRequest("session.mcp.oauth.handlePendingRequest", { sessionId, ...params }),
         /**
          * Starts OAuth authentication for a remote MCP server.
          *
-         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, and the callback success-page copy.
+         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
          *
          * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
          */
@@ -1121,7 +1182,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns A snapshot of the provider endpoint the session is currently configured to talk to.
        */
-      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { sessionId, ...params })
+      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { sessionId, ...params }),
+      /**
+       * Adds BYOK providers and/or models to the session's registry at runtime, extending the additive registry built from the session's `providers`/`models` options. Both fields are optional, so a call may add providers only, models only, or both. Within a single call providers are registered before models, so a model may reference a provider added in the same call; across calls a model may reference any provider already registered (from session creation or a prior add). A model whose referenced provider is not registered by the end of the call is rejected. Newly added models become selectable via `model.list` / `model.switchTo` and are inherited by sub-agents spawned afterwards.
+       *
+       * @param params BYOK providers and/or models to add to the session's registry at runtime. Both fields are optional; provide providers, models, or both.
+       *
+       * @returns The selectable model entries synthesized for the models added by this call.
+       */
+      add: async (params) => connection.sendRequest("session.provider.add", { sessionId, ...params })
     },
     /** @experimental */
     options: {
@@ -1804,7 +1873,7 @@ function createInternalSessionRpc(connection, sessionId) {
       /** @experimental */
       oauth: {
         /**
-         * Responds to a pending MCP OAuth provider request. Marked internal because the `provider` argument is an in-process OAuthClientProvider instance that cannot be carried over the wire; the public OAuth surface will route the response through a wire-clean handshake once the CLI moves on top of the SDK.
+         * Responds to a pending MCP OAuth request with an in-process provider. This internal CLI-only API accepts a live OAuthClientProvider instance and cannot be used over the SDK JSON-RPC boundary. Use session.mcp.oauth.handlePendingRequest instead for the public SDK-safe response path.
          *
          * @param params MCP OAuth request id and optional provider response.
          *
@@ -1816,6 +1885,11 @@ function createInternalSessionRpc(connection, sessionId) {
   };
 }
 function registerClientSessionApiHandlers(connection, getHandlers) {
+  connection.onRequest("providerToken.getToken", async (params) => {
+    const handler = getHandlers(params.sessionId).providerToken;
+    if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
+    return handler.getToken(params);
+  });
   connection.onRequest("sessionFs.readFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
@@ -1892,10 +1966,23 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     return handler.invoke(params);
   });
 }
+function registerClientGlobalApiHandlers(connection, handlers) {
+  connection.onRequest("llmInference.httpRequestStart", async (params) => {
+    const handler = handlers.llmInference;
+    if (!handler) throw new Error("No llmInference client-global handler registered");
+    return handler.httpRequestStart(params);
+  });
+  connection.onRequest("llmInference.httpRequestChunk", async (params) => {
+    const handler = handlers.llmInference;
+    if (!handler) throw new Error("No llmInference client-global handler registered");
+    return handler.httpRequestChunk(params);
+  });
+}
 export {
   createInternalServerRpc,
   createInternalSessionRpc,
   createServerRpc,
   createSessionRpc,
+  registerClientGlobalApiHandlers,
   registerClientSessionApiHandlers
 };