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

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;
@@ -364,6 +367,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 +428,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 +510,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,11 +548,14 @@ 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
@@ -620,7 +636,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."
@@ -650,16 +668,19 @@ 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)),
         workingDirectory: config.workingDirectory,
         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,
@@ -761,6 +782,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];
@@ -1131,7 +1168,7 @@ stderr: ${stderrOutput}`
           }
         }
       });
-      setTimeout(() => {
+      this.cliStartTimeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
           reject(new Error("Timeout waiting for CLI server to start"));

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

@@ -41,10 +41,21 @@ function createServerRpc(connection) {
         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)
-      }
+      },
+      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)
+    },
+    /** @experimental */
+    sessions: {
+      fork: async (params) => connection.sendRequest("sessions.fork", params)
     }
   };
 }
@@ -58,15 +69,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: {
@@ -105,10 +124,6 @@ function createSessionRpc(connection, sessionId) {
       disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
       reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
     },
-    /** @experimental */
-    compaction: {
-      compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
-    },
     tools: {
       handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
     },
@@ -126,6 +141,15 @@ function createSessionRpc(connection, sessionId) {
     shell: {
       exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
       kill: async (params) => connection.sendRequest("session.shell.kill", { sessionId, ...params })
+    },
+    /** @experimental */
+    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;
   }

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 };
 }
@@ -41,9 +86,15 @@ const SYSTEM_PROMPT_SECTIONS = {
   }
 };
 const approveAll = () => ({ kind: "approved" });
+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;

package/dist/client.js

@@ -13,7 +13,9 @@ import {
 import { createServerRpc, registerClientSessionApiHandlers } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
+import { createSessionFsAdapter } from "./sessionFsProvider.js";
 import { getTraceContext } from "./telemetry.js";
+import { defaultJoinSessionPermissionHandler } from "./types.js";
 const MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
@@ -74,6 +76,7 @@ function getBundledCliPath() {
   );
 }
 class CopilotClient {
+  cliStartTimeout = null;
   cliProcess = null;
   connection = null;
   socket = null;
@@ -344,6 +347,10 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
+    if (this.cliStartTimeout) {
+      clearTimeout(this.cliStartTimeout);
+      this.cliStartTimeout = null;
+    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
@@ -401,6 +408,10 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
+    if (this.cliStartTimeout) {
+      clearTimeout(this.cliStartTimeout);
+      this.cliStartTimeout = null;
+    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
@@ -479,7 +490,9 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     if (this.sessionFsConfig) {
       if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = config.createSessionFsHandler(session);
+        session.clientSessionApis.sessionFs = createSessionFsAdapter(
+          config.createSessionFsHandler(session)
+        );
       } else {
         throw new Error(
           "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
@@ -515,11 +528,14 @@ 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
@@ -600,7 +616,9 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     if (this.sessionFsConfig) {
       if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = config.createSessionFsHandler(session);
+        session.clientSessionApis.sessionFs = createSessionFsAdapter(
+          config.createSessionFsHandler(session)
+        );
       } else {
         throw new Error(
           "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
@@ -630,16 +648,19 @@ class CopilotClient {
         })),
         provider: config.provider,
         modelCapabilities: config.modelCapabilities,
-        requestPermission: true,
+        requestPermission: config.onPermissionRequest !== defaultJoinSessionPermissionHandler,
         requestUserInput: !!config.onUserInputRequest,
         requestElicitation: !!config.onElicitationRequest,
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
         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,
@@ -741,6 +762,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];
@@ -1111,7 +1148,7 @@ stderr: ${stderrOutput}`
           }
         }
       });
-      setTimeout(() => {
+      this.cliStartTimeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
           reject(new Error("Timeout waiting for CLI server to start"));

package/dist/extension.d.ts

@@ -1,5 +1,5 @@
 import type { CopilotSession } from "./session.js";
-import type { PermissionHandler, ResumeSessionConfig } from "./types.js";
+import { type PermissionHandler, type ResumeSessionConfig } from "./types.js";
 export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest"> & {
     onPermissionRequest?: PermissionHandler;
 };

package/dist/extension.js

@@ -1,7 +1,7 @@
 import { CopilotClient } from "./client.js";
-const defaultJoinSessionPermissionHandler = () => ({
-  kind: "no-result"
-});
+import {
+  defaultJoinSessionPermissionHandler
+} from "./types.js";
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {