@github/copilot-sdk 0.2.2 → 0.3.0-preview.1

package/README.md

@@ -86,8 +86,8 @@ new CopilotClient(options?: CopilotClientOptions)
 - `useStdio?: boolean` - Use stdio transport instead of TCP (default: true)
 - `logLevel?: string` - Log level (default: "info")
 - `autoStart?: boolean` - Auto-start server (default: true)
-- `githubToken?: string` - GitHub token for authentication. When provided, takes priority over other auth methods.
-- `useLoggedInUser?: boolean` - Whether to use logged-in user for authentication (default: true, but false when `githubToken` is provided). Cannot be used with `cliUrl`.
+- `gitHubToken?: string` - GitHub token for authentication. When provided, takes priority over other auth methods.
+- `useLoggedInUser?: boolean` - Whether to use logged-in user for authentication (default: true, but false when `gitHubToken` is provided). Cannot be used with `cliUrl`.
 - `telemetry?: TelemetryConfig` - OpenTelemetry configuration for the CLI process. Providing this object enables telemetry — no separate flag needed. See [Telemetry](#telemetry) below.
 - `onGetTraceContext?: TraceContextProvider` - Advanced: callback for linking your application's own OpenTelemetry spans into the same distributed trace as the CLI's spans. Not needed for normal telemetry collection. See [Telemetry](#telemetry) below.
 

package/dist/cjs/client.js

@@ -32,7 +32,9 @@ var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_sdkProtocolVersion = require("./sdkProtocolVersion.js");
 var import_session = require("./session.js");
+var import_sessionFsProvider = require("./sessionFsProvider.js");
 var import_telemetry = require("./telemetry.js");
+var import_types = require("./types.js");
 const import_meta = {};
 const MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
@@ -94,6 +96,7 @@ function getBundledCliPath() {
   );
 }
 class CopilotClient {
+  cliStartTimeout = null;
   cliProcess = null;
   connection = null;
   socket = null;
@@ -161,9 +164,9 @@ class CopilotClient {
         "isChildProcess must be used in conjunction with useStdio and not with cliUrl"
       );
     }
-    if (options.cliUrl && (options.githubToken || options.useLoggedInUser !== void 0)) {
+    if (options.cliUrl && (options.gitHubToken || options.useLoggedInUser !== void 0)) {
       throw new Error(
-        "githubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)"
+        "gitHubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)"
       );
     }
     if (options.sessionFs) {
@@ -195,10 +198,11 @@ class CopilotClient {
       autoStart: options.autoStart ?? true,
       autoRestart: false,
       env: effectiveEnv,
-      githubToken: options.githubToken,
-      // Default useLoggedInUser to false when githubToken is provided, otherwise true
-      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true),
-      telemetry: options.telemetry
+      gitHubToken: options.gitHubToken,
+      // Default useLoggedInUser to false when gitHubToken is provided, otherwise true
+      useLoggedInUser: options.useLoggedInUser ?? (options.gitHubToken ? false : true),
+      telemetry: options.telemetry,
+      sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0
     };
   }
   /**
@@ -364,6 +368,10 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
+    if (this.cliStartTimeout) {
+      clearTimeout(this.cliStartTimeout);
+      this.cliStartTimeout = null;
+    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
@@ -421,6 +429,10 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
+    if (this.cliStartTimeout) {
+      clearTimeout(this.cliStartTimeout);
+      this.cliStartTimeout = null;
+    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
@@ -499,7 +511,9 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     if (this.sessionFsConfig) {
       if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = config.createSessionFsHandler(session);
+        session.clientSessionApis.sessionFs = (0, import_sessionFsProvider.createSessionFsAdapter)(
+          config.createSessionFsHandler(session)
+        );
       } else {
         throw new Error(
           "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
@@ -535,15 +549,18 @@ class CopilotClient {
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
         streaming: config.streaming,
+        includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         mcpServers: config.mcpServers,
         envValueMode: "direct",
         customAgents: config.customAgents,
+        defaultAgent: config.defaultAgent,
         agent: config.agent,
         configDir: config.configDir,
         enableConfigDiscovery: config.enableConfigDiscovery,
         skillDirectories: config.skillDirectories,
         disabledSkills: config.disabledSkills,
-        infiniteSessions: config.infiniteSessions
+        infiniteSessions: config.infiniteSessions,
+        gitHubToken: config.gitHubToken
       });
       const { workspacePath, capabilities } = response;
       session["_workspacePath"] = workspacePath;
@@ -621,7 +638,9 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     if (this.sessionFsConfig) {
       if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = config.createSessionFsHandler(session);
+        session.clientSessionApis.sessionFs = (0, import_sessionFsProvider.createSessionFsAdapter)(
+          config.createSessionFsHandler(session)
+        );
       } else {
         throw new Error(
           "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
@@ -651,7 +670,7 @@ class CopilotClient {
         })),
         provider: config.provider,
         modelCapabilities: config.modelCapabilities,
-        requestPermission: true,
+        requestPermission: config.onPermissionRequest !== import_types.defaultJoinSessionPermissionHandler,
         requestUserInput: !!config.onUserInputRequest,
         requestElicitation: !!config.onElicitationRequest,
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
@@ -659,14 +678,17 @@ class CopilotClient {
         configDir: config.configDir,
         enableConfigDiscovery: config.enableConfigDiscovery,
         streaming: config.streaming,
+        includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         mcpServers: config.mcpServers,
         envValueMode: "direct",
         customAgents: config.customAgents,
+        defaultAgent: config.defaultAgent,
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         disabledSkills: config.disabledSkills,
         infiniteSessions: config.infiniteSessions,
-        disableResume: config.disableResume
+        disableResume: config.disableResume,
+        gitHubToken: config.gitHubToken
       });
       const { workspacePath, capabilities } = response;
       session["_workspacePath"] = workspacePath;
@@ -763,6 +785,22 @@ class CopilotClient {
         const result = await this.connection.sendRequest("models.list", {});
         const response = result;
         models = response.models;
+        for (const model of models) {
+          const m = model;
+          if (!m.capabilities) {
+            m.capabilities = {
+              supports: {},
+              limits: { max_context_window_tokens: 0 }
+            };
+          } else {
+            if (!m.capabilities.supports) m.capabilities.supports = {};
+            if (!m.capabilities.limits) {
+              m.capabilities.limits = { max_context_window_tokens: 0 };
+            } else if (m.capabilities.limits.max_context_window_tokens === void 0) {
+              m.capabilities.limits.max_context_window_tokens = 0;
+            }
+          }
+        }
       }
       this.modelsCache = [...models];
       return [...models];
@@ -1000,16 +1038,22 @@ class CopilotClient {
       } else if (this.options.port > 0) {
         args.push("--port", this.options.port.toString());
       }
-      if (this.options.githubToken) {
+      if (this.options.gitHubToken) {
         args.push("--auth-token-env", "COPILOT_SDK_AUTH_TOKEN");
       }
       if (!this.options.useLoggedInUser) {
         args.push("--no-auto-login");
       }
+      if (this.options.sessionIdleTimeoutSeconds !== void 0 && this.options.sessionIdleTimeoutSeconds > 0) {
+        args.push(
+          "--session-idle-timeout",
+          this.options.sessionIdleTimeoutSeconds.toString()
+        );
+      }
       const envWithoutNodeDebug = { ...this.options.env };
       delete envWithoutNodeDebug.NODE_DEBUG;
-      if (this.options.githubToken) {
-        envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.githubToken;
+      if (this.options.gitHubToken) {
+        envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.gitHubToken;
       }
       if (!this.options.cliPath) {
         throw new Error(
@@ -1133,7 +1177,7 @@ stderr: ${stderrOutput}`
           }
         }
       });
-      setTimeout(() => {
+      this.cliStartTimeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
           reject(new Error("Timeout waiting for CLI server to start"));
@@ -1390,7 +1434,7 @@ stderr: ${stderrOutput}`
       }
       return {
         result: {
-          kind: "denied-no-approval-rule-and-could-not-request-from-user"
+          kind: "user-not-available"
         }
       };
     }

package/dist/cjs/extension.js

@@ -22,9 +22,7 @@ __export(extension_exports, {
 });
 module.exports = __toCommonJS(extension_exports);
 var import_client = require("./client.js");
-const defaultJoinSessionPermissionHandler = () => ({
-  kind: "no-result"
-});
+var import_types = require("./types.js");
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -35,7 +33,7 @@ async function joinSession(config = {}) {
   const client = new import_client.CopilotClient({ isChildProcess: true });
   return client.resumeSession(sessionId, {
     ...config,
-    onPermissionRequest: config.onPermissionRequest ?? defaultJoinSessionPermissionHandler,
+    onPermissionRequest: config.onPermissionRequest ?? import_types.defaultJoinSessionPermissionHandler,
     disableResume: config.disableResume ?? true
   });
 }

package/dist/cjs/generated/rpc.js

@@ -27,21 +27,30 @@ function createServerRpc(connection) {
   return {
     ping: async (params) => connection.sendRequest("ping", params),
     models: {
-      list: async () => connection.sendRequest("models.list", {})
+      list: async (params) => connection.sendRequest("models.list", params)
     },
     tools: {
       list: async (params) => connection.sendRequest("tools.list", params)
     },
     account: {
-      getQuota: async () => connection.sendRequest("account.getQuota", {})
+      getQuota: async (params) => connection.sendRequest("account.getQuota", params)
     },
     mcp: {
       config: {
         list: async () => connection.sendRequest("mcp.config.list", {}),
         add: async (params) => connection.sendRequest("mcp.config.add", params),
         update: async (params) => connection.sendRequest("mcp.config.update", params),
-        remove: async (params) => connection.sendRequest("mcp.config.remove", params)
-      }
+        remove: async (params) => connection.sendRequest("mcp.config.remove", params),
+        enable: async (params) => connection.sendRequest("mcp.config.enable", params),
+        disable: async (params) => connection.sendRequest("mcp.config.disable", params)
+      },
+      discover: async (params) => connection.sendRequest("mcp.discover", params)
+    },
+    skills: {
+      config: {
+        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params)
+      },
+      discover: async (params) => connection.sendRequest("skills.discover", params)
     },
     sessionFs: {
       setProvider: async (params) => connection.sendRequest("sessionFs.setProvider", params)
@@ -54,6 +63,9 @@ function createServerRpc(connection) {
 }
 function createSessionRpc(connection, sessionId) {
   return {
+    auth: {
+      getStatus: async () => connection.sendRequest("session.auth.getStatus", { sessionId })
+    },
     model: {
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
       switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
@@ -62,15 +74,23 @@ function createSessionRpc(connection, sessionId) {
       get: async () => connection.sendRequest("session.mode.get", { sessionId }),
       set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
     },
+    name: {
+      get: async () => connection.sendRequest("session.name.get", { sessionId }),
+      set: async (params) => connection.sendRequest("session.name.set", { sessionId, ...params })
+    },
     plan: {
       read: async () => connection.sendRequest("session.plan.read", { sessionId }),
       update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
       delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
     },
-    workspace: {
-      listFiles: async () => connection.sendRequest("session.workspace.listFiles", { sessionId }),
-      readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
-      createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
+    workspaces: {
+      getWorkspace: async () => connection.sendRequest("session.workspaces.getWorkspace", { sessionId }),
+      listFiles: async () => connection.sendRequest("session.workspaces.listFiles", { sessionId }),
+      readFile: async (params) => connection.sendRequest("session.workspaces.readFile", { sessionId, ...params }),
+      createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { sessionId, ...params })
+    },
+    instructions: {
+      getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId })
     },
     /** @experimental */
     fleet: {
@@ -96,7 +116,11 @@ function createSessionRpc(connection, sessionId) {
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
       enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
       disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
-      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId })
+      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId }),
+      /** @experimental */
+      oauth: {
+        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
+      }
     },
     /** @experimental */
     plugins: {
@@ -120,7 +144,9 @@ function createSessionRpc(connection, sessionId) {
       handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params })
     },
     permissions: {
-      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params }),
+      setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
+      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId })
     },
     log: async (params) => connection.sendRequest("session.log", { sessionId, ...params }),
     shell: {
@@ -131,6 +157,10 @@ function createSessionRpc(connection, sessionId) {
     history: {
       compact: async () => connection.sendRequest("session.history.compact", { sessionId }),
       truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params })
+    },
+    /** @experimental */
+    usage: {
+      getMetrics: async () => connection.sendRequest("session.usage.getMetrics", { sessionId })
     }
   };
 }

package/dist/cjs/index.js

@@ -22,6 +22,8 @@ __export(index_exports, {
   CopilotSession: () => import_session.CopilotSession,
   SYSTEM_PROMPT_SECTIONS: () => import_types.SYSTEM_PROMPT_SECTIONS,
   approveAll: () => import_types.approveAll,
+  convertMcpCallToolResult: () => import_types.convertMcpCallToolResult,
+  createSessionFsAdapter: () => import_types.createSessionFsAdapter,
   defineTool: () => import_types.defineTool
 });
 module.exports = __toCommonJS(index_exports);
@@ -34,5 +36,7 @@ var import_types = require("./types.js");
   CopilotSession,
   SYSTEM_PROMPT_SECTIONS,
   approveAll,
+  convertMcpCallToolResult,
+  createSessionFsAdapter,
   defineTool
 });

package/dist/cjs/session.js

@@ -124,7 +124,8 @@ class CopilotSession {
       sessionId: this.sessionId,
       prompt: options.prompt,
       attachments: options.attachments,
-      mode: options.mode
+      mode: options.mode,
+      requestHeaders: options.requestHeaders
     });
     return response.messageId;
   }
@@ -348,7 +349,7 @@ class CopilotSession {
         await this.rpc.permissions.handlePendingPermissionRequest({
           requestId,
           result: {
-            kind: "denied-no-approval-rule-and-could-not-request-from-user"
+            kind: "user-not-available"
           }
         });
       } catch (rpcError) {
@@ -626,7 +627,7 @@ class CopilotSession {
    */
   async _handlePermissionRequestV2(request) {
     if (!this.permissionHandler) {
-      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+      return { kind: "user-not-available" };
     }
     try {
       const result = await this.permissionHandler(request, {
@@ -640,7 +641,7 @@ class CopilotSession {
       if (error instanceof Error && error.message === NO_RESULT_PERMISSION_V2_ERROR) {
         throw error;
       }
-      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
+      return { kind: "user-not-available" };
     }
   }
   /**

package/dist/cjs/sessionFsProvider.js

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sessionFsProvider_exports = {};
+__export(sessionFsProvider_exports, {
+  createSessionFsAdapter: () => createSessionFsAdapter
+});
+module.exports = __toCommonJS(sessionFsProvider_exports);
+function createSessionFsAdapter(provider) {
+  return {
+    readFile: async ({ path }) => {
+      try {
+        const content = await provider.readFile(path);
+        return { content };
+      } catch (err) {
+        return { content: "", error: toSessionFsError(err) };
+      }
+    },
+    writeFile: async ({ path, content, mode }) => {
+      try {
+        await provider.writeFile(path, content, mode);
+        return void 0;
+      } catch (err) {
+        return toSessionFsError(err);
+      }
+    },
+    appendFile: async ({ path, content, mode }) => {
+      try {
+        await provider.appendFile(path, content, mode);
+        return void 0;
+      } catch (err) {
+        return toSessionFsError(err);
+      }
+    },
+    exists: async ({ path }) => {
+      try {
+        return { exists: await provider.exists(path) };
+      } catch {
+        return { exists: false };
+      }
+    },
+    stat: async ({ path }) => {
+      try {
+        return await provider.stat(path);
+      } catch (err) {
+        return {
+          isFile: false,
+          isDirectory: false,
+          size: 0,
+          mtime: (/* @__PURE__ */ new Date()).toISOString(),
+          birthtime: (/* @__PURE__ */ new Date()).toISOString(),
+          error: toSessionFsError(err)
+        };
+      }
+    },
+    mkdir: async ({ path, recursive, mode }) => {
+      try {
+        await provider.mkdir(path, recursive ?? false, mode);
+        return void 0;
+      } catch (err) {
+        return toSessionFsError(err);
+      }
+    },
+    readdir: async ({ path }) => {
+      try {
+        const entries = await provider.readdir(path);
+        return { entries };
+      } catch (err) {
+        return { entries: [], error: toSessionFsError(err) };
+      }
+    },
+    readdirWithTypes: async ({ path }) => {
+      try {
+        const entries = await provider.readdirWithTypes(path);
+        return { entries };
+      } catch (err) {
+        return { entries: [], error: toSessionFsError(err) };
+      }
+    },
+    rm: async ({ path, recursive, force }) => {
+      try {
+        await provider.rm(path, recursive ?? false, force ?? false);
+        return void 0;
+      } catch (err) {
+        return toSessionFsError(err);
+      }
+    },
+    rename: async ({ src, dest }) => {
+      try {
+        await provider.rename(src, dest);
+        return void 0;
+      } catch (err) {
+        return toSessionFsError(err);
+      }
+    }
+  };
+}
+function toSessionFsError(err) {
+  const e = err;
+  const code = e.code === "ENOENT" ? "ENOENT" : "UNKNOWN";
+  return { code, message: e.message ?? String(err) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSessionFsAdapter
+});

package/dist/cjs/types.js

@@ -20,9 +20,54 @@ var types_exports = {};
 __export(types_exports, {
   SYSTEM_PROMPT_SECTIONS: () => SYSTEM_PROMPT_SECTIONS,
   approveAll: () => approveAll,
+  convertMcpCallToolResult: () => convertMcpCallToolResult,
+  createSessionFsAdapter: () => import_sessionFsProvider.createSessionFsAdapter,
+  defaultJoinSessionPermissionHandler: () => defaultJoinSessionPermissionHandler,
   defineTool: () => defineTool
 });
 module.exports = __toCommonJS(types_exports);
+var import_sessionFsProvider = require("./sessionFsProvider.js");
+function convertMcpCallToolResult(callResult) {
+  const textParts = [];
+  const binaryResults = [];
+  for (const block of callResult.content) {
+    switch (block.type) {
+      case "text":
+        if (typeof block.text === "string") {
+          textParts.push(block.text);
+        }
+        break;
+      case "image":
+        if (typeof block.data === "string" && block.data && typeof block.mimeType === "string") {
+          binaryResults.push({
+            data: block.data,
+            mimeType: block.mimeType,
+            type: "image"
+          });
+        }
+        break;
+      case "resource": {
+        if (block.resource?.text) {
+          textParts.push(block.resource.text);
+        }
+        if (block.resource?.blob) {
+          binaryResults.push({
+            data: block.resource.blob,
+            mimeType: block.resource.mimeType ?? "application/octet-stream",
+            type: "resource",
+            description: block.resource.uri
+          });
+        }
+        break;
+      }
+    }
+  }
+  return {
+    textResultForLlm: textParts.join("\n"),
+    resultType: callResult.isError ? "failure" : "success",
+    ...binaryResults.length > 0 ? { binaryResultsForLlm: binaryResults } : {}
+  };
+}
 function defineTool(name, config) {
   return { name, ...config };
 }
@@ -40,10 +85,16 @@ const SYSTEM_PROMPT_SECTIONS = {
     description: "End-of-prompt instructions: parallel tool calling, persistence, task completion"
   }
 };
-const approveAll = () => ({ kind: "approved" });
+const approveAll = () => ({ kind: "approve-once" });
+const defaultJoinSessionPermissionHandler = () => ({
+  kind: "no-result"
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SYSTEM_PROMPT_SECTIONS,
   approveAll,
+  convertMcpCallToolResult,
+  createSessionFsAdapter,
+  defaultJoinSessionPermissionHandler,
   defineTool
 });

package/dist/client.d.ts

@@ -35,6 +35,7 @@ import type { ConnectionState, CopilotClientOptions, GetAuthStatusResponse, GetS
  * ```
  */
 export declare class CopilotClient {
+    private cliStartTimeout;
     private cliProcess;
     private connection;
     private socket;