@github/copilot-sdk 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/cjs/session.js

@@ -397,8 +397,8 @@ class CopilotSession {
   /**
    * Registers custom tool handlers for this session.
    *
-   * Tools allow the assistant to execute custom functions. When the assistant
-   * invokes a tool, the corresponding handler is called with the tool arguments.
+   * Tools with handlers allow the assistant to execute custom functions automatically.
+   * Declaration-only tools are surfaced as events and left pending for the consumer.
    *
    * @param tools - An array of tool definitions with their handlers, or undefined to clear all tools
    * @internal This method is typically called internally when creating a session with tools.
@@ -409,7 +409,9 @@ class CopilotSession {
       return;
     }
     for (const tool of tools) {
-      this.toolHandlers.set(tool.name, tool.handler);
+      if (tool.handler) {
+        this.toolHandlers.set(tool.name, tool.handler);
+      }
     }
   }
   /**

package/dist/cjs/sessionFsProvider.js

@@ -21,6 +21,18 @@ __export(sessionFsProvider_exports, {
   createSessionFsAdapter: () => createSessionFsAdapter
 });
 module.exports = __toCommonJS(sessionFsProvider_exports);
+function normalizeSqliteParams(params) {
+  if (!params) {
+    return void 0;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
 function createSessionFsAdapter(provider) {
   return {
     readFile: async ({ path }) => {
@@ -107,6 +119,28 @@ function createSessionFsAdapter(provider) {
       } catch (err) {
         return toSessionFsError(err);
       }
+    },
+    // Unlike the FS methods above, SQLite methods let errors propagate to the JSON-RPC layer
+    // rather than catching and mapping via toSessionFsError. The FS error mapping is specifically
+    // for translating Node.js errno codes (e.g., ENOENT) into SessionFsError, which isn't
+    // meaningful for SQL errors. Letting exceptions propagate preserves the original error
+    // message in the JSON-RPC error response.
+    sqliteQuery: async ({ queryType, query, params: bindParams }) => {
+      if (!provider.sqlite) {
+        throw new Error("SQLite is not supported by this provider");
+      }
+      const result = await provider.sqlite.query(
+        queryType,
+        query,
+        normalizeSqliteParams(bindParams)
+      );
+      return result ?? { rows: [], columns: [], rowsAffected: 0 };
+    },
+    sqliteExists: async () => {
+      if (!provider.sqlite) {
+        throw new Error("SQLite is not supported by this provider");
+      }
+      return { exists: await provider.sqlite.exists() };
     }
   };
 }

package/dist/client.d.ts

@@ -99,6 +99,7 @@ export declare class CopilotClient {
      */
     private parseCliUrl;
     private validateSessionFsConfig;
+    private setupSessionFs;
     /**
      * Starts the CLI server and establishes a connection.
      *
@@ -251,7 +252,7 @@ export declare class CopilotClient {
      */
     ping(message?: string): Promise<{
         message: string;
-        timestamp: number;
+        timestamp: string;
         protocolVersion?: number;
     }>;
     /**

package/dist/client.js

@@ -258,6 +258,23 @@ class CopilotClient {
       throw new Error("sessionFs.conventions must be either 'windows' or 'posix'");
     }
   }
+  setupSessionFs(session, config) {
+    if (!this.sessionFsConfig) {
+      return;
+    }
+    if (!config.createSessionFsHandler) {
+      throw new Error(
+        "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
+      );
+    }
+    const provider = config.createSessionFsHandler(session);
+    if (this.sessionFsConfig.capabilities?.sqlite && !provider.sqlite) {
+      throw new Error(
+        "SessionFsConfig declares capabilities.sqlite but the provider does not implement sqlite."
+      );
+    }
+    session.clientSessionApis.sessionFs = createSessionFsAdapter(provider);
+  }
   /**
    * Starts the CLI server and establishes a connection.
    *
@@ -291,7 +308,8 @@ class CopilotClient {
         await this.connection.sendRequest("sessionFs.setProvider", {
           initialCwd: this.sessionFsConfig.initialCwd,
           sessionStatePath: this.sessionFsConfig.sessionStatePath,
-          conventions: this.sessionFsConfig.conventions
+          conventions: this.sessionFsConfig.conventions,
+          capabilities: this.sessionFsConfig.capabilities
         });
       }
       this.state = "connected";
@@ -488,11 +506,6 @@ class CopilotClient {
    * ```
    */
   async createSession(config) {
-    if (!config?.onPermissionRequest) {
-      throw new Error(
-        "An onPermissionRequest handler is required when creating a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }."
-      );
-    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -535,17 +548,7 @@ class CopilotClient {
       session.on(config.onEvent);
     }
     this.sessions.set(sessionId, session);
-    if (this.sessionFsConfig) {
-      if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = createSessionFsAdapter(
-          config.createSessionFsHandler(session)
-        );
-      } else {
-        throw new Error(
-          "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
-        );
-      }
-    }
+    this.setupSessionFs(session, config);
     try {
       const response = await this.connection.sendRequest("session.create", {
         ...await getTraceContext(this.onGetTraceContext),
@@ -590,7 +593,9 @@ class CopilotClient {
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
         infiniteSessions: config.infiniteSessions,
-        gitHubToken: config.gitHubToken
+        gitHubToken: config.gitHubToken,
+        remoteSession: config.remoteSession,
+        cloud: config.cloud
       });
       const { workspacePath, capabilities } = response;
       session["_workspacePath"] = workspacePath;
@@ -626,11 +631,6 @@ class CopilotClient {
    * ```
    */
   async resumeSession(sessionId, config) {
-    if (!config?.onPermissionRequest) {
-      throw new Error(
-        "An onPermissionRequest handler is required when resuming a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }."
-      );
-    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -672,17 +672,7 @@ class CopilotClient {
       session.on(config.onEvent);
     }
     this.sessions.set(sessionId, session);
-    if (this.sessionFsConfig) {
-      if (config.createSessionFsHandler) {
-        session.clientSessionApis.sessionFs = createSessionFsAdapter(
-          config.createSessionFsHandler(session)
-        );
-      } else {
-        throw new Error(
-          "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
-        );
-      }
-    }
+    this.setupSessionFs(session, config);
     try {
       const response = await this.connection.sendRequest("session.resume", {
         ...await getTraceContext(this.onGetTraceContext),
@@ -729,7 +719,8 @@ class CopilotClient {
         infiniteSessions: config.infiniteSessions,
         disableResume: config.disableResume,
         continuePendingWork: config.continuePendingWork,
-        gitHubToken: config.gitHubToken
+        gitHubToken: config.gitHubToken,
+        remoteSession: config.remoteSession
       });
       const { workspacePath, capabilities } = response;
       session["_workspacePath"] = workspacePath;
@@ -1300,7 +1291,12 @@ stderr: ${stderrOutput}`
     }
     return new Promise((resolve, reject) => {
       this.socket = new Socket();
+      const connectionTimeout = setTimeout(() => {
+        this.socket?.destroy();
+        reject(new Error("Timeout connecting to CLI server"));
+      }, 1e4);
       this.socket.connect(this.actualPort, this.actualHost, () => {
+        clearTimeout(connectionTimeout);
         this.connection = createMessageConnection(
           new StreamMessageReader(this.socket),
           new StreamMessageWriter(this.socket)
@@ -1310,6 +1306,7 @@ stderr: ${stderrOutput}`
         resolve();
       });
       this.socket.on("error", (error) => {
+        clearTimeout(connectionTimeout);
         reject(new Error(`Failed to connect to CLI server: ${error.message}`));
       });
     });