vidpipe 1.3.29 → 1.3.31

package/dist/cli.js

@@ -6207,18 +6207,45 @@ 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),
+        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)
+    },
+    /** @experimental */
+    sessions: {
+      fork: async (params) => connection.sendRequest("sessions.fork", params)
     }
   };
 }
 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 })
@@ -6227,15 +6254,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: {
@@ -6261,7 +6296,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: {
@@ -6274,10 +6313,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 })
     },
@@ -6285,18 +6320,82 @@ function createSessionRpc(connection, sessionId) {
       handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
     },
     ui: {
-      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params })
+      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params }),
+      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: {
       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 })
     }
   };
 }
+function registerClientSessionApiHandlers(connection, getHandlers) {
+  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}`);
+    return handler.readFile(params);
+  });
+  connection.onRequest("sessionFs.writeFile", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.writeFile(params);
+  });
+  connection.onRequest("sessionFs.appendFile", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.appendFile(params);
+  });
+  connection.onRequest("sessionFs.exists", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.exists(params);
+  });
+  connection.onRequest("sessionFs.stat", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.stat(params);
+  });
+  connection.onRequest("sessionFs.mkdir", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.mkdir(params);
+  });
+  connection.onRequest("sessionFs.readdir", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readdir(params);
+  });
+  connection.onRequest("sessionFs.readdirWithTypes", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readdirWithTypes(params);
+  });
+  connection.onRequest("sessionFs.rm", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.rm(params);
+  });
+  connection.onRequest("sessionFs.rename", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.rename(params);
+  });
+}
 var init_rpc = __esm({
   "node_modules/@github/copilot-sdk/dist/generated/rpc.js"() {
     "use strict";
@@ -6331,6 +6430,25 @@ var init_telemetry = __esm({
 });
 
 // node_modules/@github/copilot-sdk/dist/session.js
+function isToolResultObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("textResultForLlm" in value) || typeof value.textResultForLlm !== "string") {
+    return false;
+  }
+  if (!("resultType" in value) || typeof value.resultType !== "string") {
+    return false;
+  }
+  const allowedResultTypes = [
+    "success",
+    "failure",
+    "rejected",
+    "denied",
+    "timeout"
+  ];
+  return allowedResultTypes.includes(value.resultType);
+}
 var import_node, NO_RESULT_PERMISSION_V2_ERROR, CopilotSession;
 var init_session = __esm({
   "node_modules/@github/copilot-sdk/dist/session.js"() {
@@ -6358,12 +6476,17 @@ var init_session = __esm({
       eventHandlers = /* @__PURE__ */ new Set();
       typedEventHandlers = /* @__PURE__ */ new Map();
       toolHandlers = /* @__PURE__ */ new Map();
+      commandHandlers = /* @__PURE__ */ new Map();
       permissionHandler;
       userInputHandler;
+      elicitationHandler;
       hooks;
       transformCallbacks;
       _rpc = null;
       traceContextProvider;
+      _capabilities = {};
+      /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
+      clientSessionApis = {};
       /**
        * Typed session-scoped RPC methods.
        */
@@ -6381,6 +6504,33 @@ var init_session = __esm({
       get workspacePath() {
         return this._workspacePath;
       }
+      /**
+       * Host capabilities reported when the session was created or resumed.
+       * Use this to check feature support before calling capability-gated APIs.
+       */
+      get capabilities() {
+        return this._capabilities;
+      }
+      /**
+       * Interactive UI methods for showing dialogs to the user.
+       * Only available when the CLI host supports elicitation
+       * (`session.capabilities.ui?.elicitation === true`).
+       *
+       * @example
+       * ```typescript
+       * if (session.capabilities.ui?.elicitation) {
+       *   const ok = await session.ui.confirm("Deploy to production?");
+       * }
+       * ```
+       */
+      get ui() {
+        return {
+          elicitation: (params) => this._elicitation(params),
+          confirm: (message) => this._confirm(message),
+          select: (message, options) => this._select(message, options),
+          input: (message, options) => this._input(message, options)
+        };
+      }
       /**
        * Sends a message to this session and waits for the response.
        *
@@ -6405,7 +6555,8 @@ var init_session = __esm({
           sessionId: this.sessionId,
           prompt: options.prompt,
           attachments: options.attachments,
-          mode: options.mode
+          mode: options.mode,
+          requestHeaders: options.requestHeaders
         });
         return response.messageId;
       }
@@ -6546,10 +6697,33 @@ var init_session = __esm({
             );
           }
         } else if (event.type === "permission.requested") {
-          const { requestId, permissionRequest } = event.data;
+          const { requestId, permissionRequest, resolvedByHook } = event.data;
+          if (resolvedByHook) {
+            return;
+          }
           if (this.permissionHandler) {
             void this._executePermissionAndRespond(requestId, permissionRequest);
           }
+        } else if (event.type === "command.execute") {
+          const { requestId, commandName, command, args } = event.data;
+          void this._executeCommandAndRespond(requestId, commandName, command, args);
+        } else if (event.type === "elicitation.requested") {
+          if (this.elicitationHandler) {
+            const { message, requestedSchema, mode, elicitationSource, url, requestId } = event.data;
+            void this._handleElicitationRequest(
+              {
+                sessionId: this.sessionId,
+                message,
+                requestedSchema,
+                mode,
+                elicitationSource,
+                url
+              },
+              requestId
+            );
+          }
+        } else if (event.type === "capabilities.changed") {
+          this._capabilities = { ...this._capabilities, ...event.data };
         }
       }
       /**
@@ -6571,6 +6745,8 @@ var init_session = __esm({
             result = "";
           } else if (typeof rawResult === "string") {
             result = rawResult;
+          } else if (isToolResultObject(rawResult)) {
+            result = rawResult;
           } else {
             result = JSON.stringify(rawResult);
           }
@@ -6604,7 +6780,7 @@ var init_session = __esm({
             await this.rpc.permissions.handlePendingPermissionRequest({
               requestId,
               result: {
-                kind: "denied-no-approval-rule-and-could-not-request-from-user"
+                kind: "user-not-available"
               }
             });
           } catch (rpcError) {
@@ -6614,6 +6790,39 @@ var init_session = __esm({
           }
         }
       }
+      /**
+       * Executes a command handler and sends the result back via RPC.
+       * @internal
+       */
+      async _executeCommandAndRespond(requestId, commandName, command, args) {
+        const handler = this.commandHandlers.get(commandName);
+        if (!handler) {
+          try {
+            await this.rpc.commands.handlePendingCommand({
+              requestId,
+              error: `Unknown command: ${commandName}`
+            });
+          } catch (rpcError) {
+            if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+              throw rpcError;
+            }
+          }
+          return;
+        }
+        try {
+          await handler({ sessionId: this.sessionId, command, commandName, args });
+          await this.rpc.commands.handlePendingCommand({ requestId });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          try {
+            await this.rpc.commands.handlePendingCommand({ requestId, error: message });
+          } catch (rpcError) {
+            if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+              throw rpcError;
+            }
+          }
+        }
+      }
       /**
        * Registers custom tool handlers for this session.
        *
@@ -6642,6 +6851,133 @@ var init_session = __esm({
       getToolHandler(name) {
         return this.toolHandlers.get(name);
       }
+      /**
+       * Registers command handlers for this session.
+       *
+       * @param commands - An array of command definitions with handlers, or undefined to clear
+       * @internal This method is typically called internally when creating/resuming a session.
+       */
+      registerCommands(commands) {
+        this.commandHandlers.clear();
+        if (!commands) {
+          return;
+        }
+        for (const cmd of commands) {
+          this.commandHandlers.set(cmd.name, cmd.handler);
+        }
+      }
+      /**
+       * Registers the elicitation handler for this session.
+       *
+       * @param handler - The handler to invoke when the server dispatches an elicitation request
+       * @internal This method is typically called internally when creating/resuming a session.
+       */
+      registerElicitationHandler(handler) {
+        this.elicitationHandler = handler;
+      }
+      /**
+       * Handles an elicitation.requested broadcast event.
+       * Invokes the registered handler and responds via handlePendingElicitation RPC.
+       * @internal
+       */
+      async _handleElicitationRequest(context, requestId) {
+        if (!this.elicitationHandler) {
+          return;
+        }
+        try {
+          const result = await this.elicitationHandler(context);
+          await this.rpc.ui.handlePendingElicitation({ requestId, result });
+        } catch {
+          try {
+            await this.rpc.ui.handlePendingElicitation({
+              requestId,
+              result: { action: "cancel" }
+            });
+          } catch (rpcError) {
+            if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+              throw rpcError;
+            }
+          }
+        }
+      }
+      /**
+       * Sets the host capabilities for this session.
+       *
+       * @param capabilities - The capabilities object from the create/resume response
+       * @internal This method is typically called internally when creating/resuming a session.
+       */
+      setCapabilities(capabilities) {
+        this._capabilities = capabilities ?? {};
+      }
+      assertElicitation() {
+        if (!this._capabilities.ui?.elicitation) {
+          throw new Error(
+            "Elicitation is not supported by the host. Check session.capabilities.ui?.elicitation before calling UI methods."
+          );
+        }
+      }
+      async _elicitation(params) {
+        this.assertElicitation();
+        return this.rpc.ui.elicitation({
+          message: params.message,
+          requestedSchema: params.requestedSchema
+        });
+      }
+      async _confirm(message) {
+        this.assertElicitation();
+        const result = await this.rpc.ui.elicitation({
+          message,
+          requestedSchema: {
+            type: "object",
+            properties: {
+              confirmed: { type: "boolean", default: true }
+            },
+            required: ["confirmed"]
+          }
+        });
+        return result.action === "accept" && result.content?.confirmed === true;
+      }
+      async _select(message, options) {
+        this.assertElicitation();
+        const result = await this.rpc.ui.elicitation({
+          message,
+          requestedSchema: {
+            type: "object",
+            properties: {
+              selection: { type: "string", enum: options }
+            },
+            required: ["selection"]
+          }
+        });
+        if (result.action === "accept" && result.content?.selection != null) {
+          return result.content.selection;
+        }
+        return null;
+      }
+      async _input(message, options) {
+        this.assertElicitation();
+        const field = { type: "string" };
+        if (options?.title) field.title = options.title;
+        if (options?.description) field.description = options.description;
+        if (options?.minLength != null) field.minLength = options.minLength;
+        if (options?.maxLength != null) field.maxLength = options.maxLength;
+        if (options?.format) field.format = options.format;
+        if (options?.default != null) field.default = options.default;
+        const result = await this.rpc.ui.elicitation({
+          message,
+          requestedSchema: {
+            type: "object",
+            properties: {
+              value: field
+            },
+            required: ["value"]
+          }
+        });
+        if (result.action === "accept" && result.content?.value != null) {
+          return result.content.value;
+        }
+        return null;
+      }
       /**
        * Registers a handler for permission requests.
        *
@@ -6722,7 +7058,7 @@ var init_session = __esm({
        */
       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, {
@@ -6736,7 +7072,7 @@ var init_session = __esm({
           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" };
         }
       }
       /**
@@ -6925,6 +7261,120 @@ var init_session = __esm({
   }
 });
 
+// node_modules/@github/copilot-sdk/dist/sessionFsProvider.js
+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) };
+}
+var init_sessionFsProvider = __esm({
+  "node_modules/@github/copilot-sdk/dist/sessionFsProvider.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@github/copilot-sdk/dist/types.js
+var approveAll, defaultJoinSessionPermissionHandler;
+var init_types3 = __esm({
+  "node_modules/@github/copilot-sdk/dist/types.js"() {
+    "use strict";
+    init_sessionFsProvider();
+    approveAll = () => ({ kind: "approve-once" });
+    defaultJoinSessionPermissionHandler = () => ({
+      kind: "no-result"
+    });
+  }
+});
+
 // node_modules/@github/copilot-sdk/dist/client.js
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
@@ -6999,9 +7449,12 @@ var init_client = __esm({
     init_rpc();
     init_sdkProtocolVersion();
     init_session();
+    init_sessionFsProvider();
     init_telemetry();
+    init_types3();
     MIN_PROTOCOL_VERSION = 2;
-    CopilotClient = class {
+    CopilotClient = class _CopilotClient {
+      cliStartTimeout = null;
       cliProcess = null;
       connection = null;
       socket = null;
@@ -7024,6 +7477,8 @@ var init_client = __esm({
       processExitPromise = null;
       // Rejects when CLI process exits
       negotiatedProtocolVersion = null;
+      /** Connection-level session filesystem config, set via constructor option. */
+      sessionFsConfig = null;
       /**
        * Typed server-scoped RPC methods.
        * @throws Error if the client is not connected
@@ -7067,11 +7522,14 @@ var init_client = __esm({
             "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) {
+          this.validateSessionFsConfig(options.sessionFs);
+        }
         if (options.cliUrl) {
           const { host, port } = this.parseCliUrl(options.cliUrl);
           this.actualHost = host;
@@ -7083,8 +7541,10 @@ var init_client = __esm({
         }
         this.onListModels = options.onListModels;
         this.onGetTraceContext = options.onGetTraceContext;
+        this.sessionFsConfig = options.sessionFs ?? null;
+        const effectiveEnv = options.env ?? process.env;
         this.options = {
-          cliPath: options.cliUrl ? void 0 : options.cliPath || getBundledCliPath(),
+          cliPath: options.cliUrl ? void 0 : options.cliPath || effectiveEnv.COPILOT_CLI_PATH || getBundledCliPath(),
           cliArgs: options.cliArgs ?? [],
           cwd: options.cwd ?? process.cwd(),
           port: options.port || 0,
@@ -7095,11 +7555,12 @@ var init_client = __esm({
           logLevel: options.logLevel || "debug",
           autoStart: options.autoStart ?? true,
           autoRestart: false,
-          env: options.env ?? process.env,
-          githubToken: options.githubToken,
-          // Default useLoggedInUser to false when githubToken is provided, otherwise true
-          useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true),
-          telemetry: options.telemetry
+          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,
+          sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0
         };
       }
       /**
@@ -7124,6 +7585,17 @@ var init_client = __esm({
         }
         return { host, port };
       }
+      validateSessionFsConfig(config2) {
+        if (!config2.initialCwd) {
+          throw new Error("sessionFs.initialCwd is required");
+        }
+        if (!config2.sessionStatePath) {
+          throw new Error("sessionFs.sessionStatePath is required");
+        }
+        if (config2.conventions !== "windows" && config2.conventions !== "posix") {
+          throw new Error("sessionFs.conventions must be either 'windows' or 'posix'");
+        }
+      }
       /**
        * Starts the CLI server and establishes a connection.
        *
@@ -7153,6 +7625,13 @@ var init_client = __esm({
           }
           await this.connectToServer();
           await this.verifyProtocolVersion();
+          if (this.sessionFsConfig) {
+            await this.connection.sendRequest("sessionFs.setProvider", {
+              initialCwd: this.sessionFsConfig.initialCwd,
+              sessionStatePath: this.sessionFsConfig.sessionStatePath,
+              conventions: this.sessionFsConfig.conventions
+            });
+          }
           this.state = "connected";
         } catch (error) {
           this.state = "error";
@@ -7247,6 +7726,10 @@ var init_client = __esm({
           }
           this.cliProcess = null;
         }
+        if (this.cliStartTimeout) {
+          clearTimeout(this.cliStartTimeout);
+          this.cliStartTimeout = null;
+        }
         this.state = "disconnected";
         this.actualPort = null;
         this.stderrBuffer = "";
@@ -7304,6 +7787,10 @@ var init_client = __esm({
           }
           this.cliProcess = null;
         }
+        if (this.cliStartTimeout) {
+          clearTimeout(this.cliStartTimeout);
+          this.cliStartTimeout = null;
+        }
         this.state = "disconnected";
         this.actualPort = null;
         this.stderrBuffer = "";
@@ -7359,10 +7846,14 @@ var init_client = __esm({
           this.onGetTraceContext
         );
         session.registerTools(config2.tools);
+        session.registerCommands(config2.commands);
         session.registerPermissionHandler(config2.onPermissionRequest);
         if (config2.onUserInputRequest) {
           session.registerUserInputHandler(config2.onUserInputRequest);
         }
+        if (config2.onElicitationRequest) {
+          session.registerElicitationHandler(config2.onElicitationRequest);
+        }
         if (config2.hooks) {
           session.registerHooks(config2.hooks);
         }
@@ -7376,6 +7867,17 @@ var init_client = __esm({
           session.on(config2.onEvent);
         }
         this.sessions.set(sessionId, session);
+        if (this.sessionFsConfig) {
+          if (config2.createSessionFsHandler) {
+            session.clientSessionApis.sessionFs = createSessionFsAdapter(
+              config2.createSessionFsHandler(session)
+            );
+          } else {
+            throw new Error(
+              "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
+            );
+          }
+        }
         try {
           const response = await this.connection.sendRequest("session.create", {
             ...await getTraceContext(this.onGetTraceContext),
@@ -7390,26 +7892,37 @@ var init_client = __esm({
               overridesBuiltInTool: tool.overridesBuiltInTool,
               skipPermission: tool.skipPermission
             })),
+            commands: config2.commands?.map((cmd) => ({
+              name: cmd.name,
+              description: cmd.description
+            })),
             systemMessage: wireSystemMessage,
             availableTools: config2.availableTools,
             excludedTools: config2.excludedTools,
             provider: config2.provider,
+            modelCapabilities: config2.modelCapabilities,
             requestPermission: true,
             requestUserInput: !!config2.onUserInputRequest,
+            requestElicitation: !!config2.onElicitationRequest,
             hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
             workingDirectory: config2.workingDirectory,
             streaming: config2.streaming,
+            includeSubAgentStreamingEvents: config2.includeSubAgentStreamingEvents ?? true,
             mcpServers: config2.mcpServers,
             envValueMode: "direct",
             customAgents: config2.customAgents,
+            defaultAgent: config2.defaultAgent,
             agent: config2.agent,
             configDir: config2.configDir,
+            enableConfigDiscovery: config2.enableConfigDiscovery,
             skillDirectories: config2.skillDirectories,
             disabledSkills: config2.disabledSkills,
-            infiniteSessions: config2.infiniteSessions
+            infiniteSessions: config2.infiniteSessions,
+            gitHubToken: config2.gitHubToken
           });
-          const { workspacePath } = response;
+          const { workspacePath, capabilities } = response;
           session["_workspacePath"] = workspacePath;
+          session.setCapabilities(capabilities);
         } catch (e) {
           this.sessions.delete(sessionId);
           throw e;
@@ -7460,10 +7973,14 @@ var init_client = __esm({
           this.onGetTraceContext
         );
         session.registerTools(config2.tools);
+        session.registerCommands(config2.commands);
         session.registerPermissionHandler(config2.onPermissionRequest);
         if (config2.onUserInputRequest) {
           session.registerUserInputHandler(config2.onUserInputRequest);
         }
+        if (config2.onElicitationRequest) {
+          session.registerElicitationHandler(config2.onElicitationRequest);
+        }
         if (config2.hooks) {
           session.registerHooks(config2.hooks);
         }
@@ -7477,6 +7994,17 @@ var init_client = __esm({
           session.on(config2.onEvent);
         }
         this.sessions.set(sessionId, session);
+        if (this.sessionFsConfig) {
+          if (config2.createSessionFsHandler) {
+            session.clientSessionApis.sessionFs = createSessionFsAdapter(
+              config2.createSessionFsHandler(session)
+            );
+          } else {
+            throw new Error(
+              "createSessionFsHandler is required in session config when sessionFs is enabled in client options."
+            );
+          }
+        }
         try {
           const response = await this.connection.sendRequest("session.resume", {
             ...await getTraceContext(this.onGetTraceContext),
@@ -7494,24 +8022,35 @@ var init_client = __esm({
               overridesBuiltInTool: tool.overridesBuiltInTool,
               skipPermission: tool.skipPermission
             })),
+            commands: config2.commands?.map((cmd) => ({
+              name: cmd.name,
+              description: cmd.description
+            })),
             provider: config2.provider,
-            requestPermission: true,
+            modelCapabilities: config2.modelCapabilities,
+            requestPermission: config2.onPermissionRequest !== defaultJoinSessionPermissionHandler,
             requestUserInput: !!config2.onUserInputRequest,
+            requestElicitation: !!config2.onElicitationRequest,
             hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
             workingDirectory: config2.workingDirectory,
             configDir: config2.configDir,
+            enableConfigDiscovery: config2.enableConfigDiscovery,
             streaming: config2.streaming,
+            includeSubAgentStreamingEvents: config2.includeSubAgentStreamingEvents ?? true,
             mcpServers: config2.mcpServers,
             envValueMode: "direct",
             customAgents: config2.customAgents,
+            defaultAgent: config2.defaultAgent,
             agent: config2.agent,
             skillDirectories: config2.skillDirectories,
             disabledSkills: config2.disabledSkills,
             infiniteSessions: config2.infiniteSessions,
-            disableResume: config2.disableResume
+            disableResume: config2.disableResume,
+            gitHubToken: config2.gitHubToken
           });
-          const { workspacePath } = response;
+          const { workspacePath, capabilities } = response;
           session["_workspacePath"] = workspacePath;
+          session.setCapabilities(capabilities);
         } catch (e) {
           this.sessions.delete(sessionId);
           throw e;
@@ -7604,6 +8143,22 @@ var init_client = __esm({
             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];
@@ -7707,16 +8262,50 @@ var init_client = __esm({
         if (!this.connection) {
           throw new Error("Client not connected");
         }
-        const response = await this.connection.sendRequest("session.list", { filter });
+        const response = await this.connection.sendRequest("session.list", {
+          filter
+        });
         const { sessions } = response;
-        return sessions.map((s) => ({
-          sessionId: s.sessionId,
-          startTime: new Date(s.startTime),
-          modifiedTime: new Date(s.modifiedTime),
-          summary: s.summary,
-          isRemote: s.isRemote,
-          context: s.context
-        }));
+        return sessions.map(_CopilotClient.toSessionMetadata);
+      }
+      /**
+       * Gets metadata for a specific session by ID.
+       *
+       * This provides an efficient O(1) lookup of a single session's metadata
+       * instead of listing all sessions. Returns undefined if the session is not found.
+       *
+       * @param sessionId - The ID of the session to look up
+       * @returns A promise that resolves with the session metadata, or undefined if not found
+       * @throws Error if the client is not connected
+       *
+       * @example
+       * ```typescript
+       * const metadata = await client.getSessionMetadata("session-123");
+       * if (metadata) {
+       *   console.log(`Session started at: ${metadata.startTime}`);
+       * }
+       * ```
+       */
+      async getSessionMetadata(sessionId) {
+        if (!this.connection) {
+          throw new Error("Client not connected");
+        }
+        const response = await this.connection.sendRequest("session.getMetadata", { sessionId });
+        const { session } = response;
+        if (!session) {
+          return void 0;
+        }
+        return _CopilotClient.toSessionMetadata(session);
+      }
+      static toSessionMetadata(raw) {
+        return {
+          sessionId: raw.sessionId,
+          startTime: new Date(raw.startTime),
+          modifiedTime: new Date(raw.modifiedTime),
+          summary: raw.summary,
+          isRemote: raw.isRemote,
+          context: raw.context
+        };
       }
       /**
        * Gets the foreground session ID in TUI+server mode.
@@ -7807,16 +8396,22 @@ var init_client = __esm({
           } 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(
@@ -7940,7 +8535,7 @@ stderr: ${stderrOutput}`
               }
             }
           });
-          setTimeout(() => {
+          this.cliStartTimeout = setTimeout(() => {
             if (!resolved) {
               resolved = true;
               reject(new Error("Timeout waiting for CLI server to start"));
@@ -8046,6 +8641,12 @@ stderr: ${stderrOutput}`
           "systemMessage.transform",
           async (params) => await this.handleSystemMessageTransform(params)
         );
+        const sessions = this.sessions;
+        registerClientSessionApiHandlers(this.connection, (sessionId) => {
+          const session = sessions.get(sessionId);
+          if (!session) throw new Error(`No session found for sessionId: ${sessionId}`);
+          return session.clientSessionApis;
+        });
         this.connection.onClose(() => {
           this.state = "disconnected";
         });
@@ -8191,7 +8792,7 @@ stderr: ${stderrOutput}`
           }
           return {
             result: {
-              kind: "denied-no-approval-rule-and-could-not-request-from-user"
+              kind: "user-not-available"
             }
           };
         }
@@ -8222,15 +8823,6 @@ stderr: ${stderrOutput}`
   }
 });
 
-// node_modules/@github/copilot-sdk/dist/types.js
-var approveAll;
-var init_types3 = __esm({
-  "node_modules/@github/copilot-sdk/dist/types.js"() {
-    "use strict";
-    approveAll = () => ({ kind: "approved" });
-  }
-});
-
 // node_modules/@github/copilot-sdk/dist/index.js
 var init_dist = __esm({
   "node_modules/@github/copilot-sdk/dist/index.js"() {