contribute-now 0.10.0-patch.647137a → 0.10.0

package/dist/cli.js

@@ -6427,44 +6427,18 @@ function createServerRpc(connection) {
   return {
     ping: async (params) => connection.sendRequest("ping", params),
     models: {
-      list: async (params) => connection.sendRequest("models.list", params)
+      list: async () => connection.sendRequest("models.list", {})
     },
     tools: {
       list: async (params) => connection.sendRequest("tools.list", params)
     },
     account: {
-      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)
-    },
-    sessions: {
-      fork: async (params) => connection.sendRequest("sessions.fork", params)
+      getQuota: async () => connection.sendRequest("account.getQuota", {})
     }
   };
 }
 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 })
@@ -6473,849 +6447,231 @@ 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 })
     },
-    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 })
+    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 })
     },
     fleet: {
       start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
-    },
-    agent: {
-      list: async () => connection.sendRequest("session.agent.list", { sessionId }),
-      getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
-      select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
-      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId }),
-      reload: async () => connection.sendRequest("session.agent.reload", { sessionId })
-    },
-    skills: {
-      list: async () => connection.sendRequest("session.skills.list", { sessionId }),
-      enable: async (params) => connection.sendRequest("session.skills.enable", { sessionId, ...params }),
-      disable: async (params) => connection.sendRequest("session.skills.disable", { sessionId, ...params }),
-      reload: async () => connection.sendRequest("session.skills.reload", { sessionId })
-    },
-    mcp: {
-      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 }),
-      oauth: {
-        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
-      }
-    },
-    plugins: {
-      list: async () => connection.sendRequest("session.plugins.list", { sessionId })
-    },
-    extensions: {
-      list: async () => connection.sendRequest("session.extensions.list", { sessionId }),
-      enable: async (params) => connection.sendRequest("session.extensions.enable", { sessionId, ...params }),
-      disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
-      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
-    },
-    tools: {
-      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
-    },
-    commands: {
-      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
-    },
-    ui: {
-      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 }),
-      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 })
-    },
-    history: {
-      compact: async () => connection.sendRequest("session.history.compact", { sessionId }),
-      truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params })
-    },
-    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 = () => {};
 
 // node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
 function getSdkProtocolVersion() {
   return SDK_PROTOCOL_VERSION;
 }
-var SDK_PROTOCOL_VERSION = 3;
+var SDK_PROTOCOL_VERSION = 2;
 var init_sdkProtocolVersion = () => {};
 
-// node_modules/@github/copilot-sdk/dist/telemetry.js
-async function getTraceContext(provider) {
-  if (!provider)
-    return {};
-  try {
-    return await provider() ?? {};
-  } catch {
-    return {};
-  }
-}
-var init_telemetry = () => {};
-
 // 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;
+class CopilotSession {
+  constructor(sessionId, connection, _workspacePath) {
+    this.sessionId = sessionId;
+    this.connection = connection;
+    this._workspacePath = _workspacePath;
+  }
+  eventHandlers = /* @__PURE__ */ new Set;
+  typedEventHandlers = /* @__PURE__ */ new Map;
+  toolHandlers = /* @__PURE__ */ new Map;
+  permissionHandler;
+  userInputHandler;
+  hooks;
+  _rpc = null;
+  get rpc() {
+    if (!this._rpc) {
+      this._rpc = createSessionRpc(this.connection, this.sessionId);
+    }
+    return this._rpc;
   }
-  if (!("resultType" in value) || typeof value.resultType !== "string") {
-    return false;
+  get workspacePath() {
+    return this._workspacePath;
   }
-  const allowedResultTypes = [
-    "success",
-    "failure",
-    "rejected",
-    "denied",
-    "timeout"
-  ];
-  return allowedResultTypes.includes(value.resultType);
-}
-var import_node, NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.", CopilotSession;
-var init_session = __esm(() => {
-  init_rpc();
-  init_telemetry();
-  import_node = __toESM(require_main(), 1);
-  CopilotSession = class CopilotSession {
-    constructor(sessionId, connection, _workspacePath, traceContextProvider) {
-      this.sessionId = sessionId;
-      this.connection = connection;
-      this._workspacePath = _workspacePath;
-      this.traceContextProvider = traceContextProvider;
-    }
-    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 = {};
-    clientSessionApis = {};
-    get rpc() {
-      if (!this._rpc) {
-        this._rpc = createSessionRpc(this.connection, this.sessionId);
-      }
-      return this._rpc;
-    }
-    get workspacePath() {
-      return this._workspacePath;
-    }
-    get capabilities() {
-      return this._capabilities;
-    }
-    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)
-      };
-    }
-    async send(options) {
-      const response = await this.connection.sendRequest("session.send", {
-        ...await getTraceContext(this.traceContextProvider),
-        sessionId: this.sessionId,
-        prompt: options.prompt,
-        attachments: options.attachments,
-        mode: options.mode,
-        requestHeaders: options.requestHeaders
-      });
-      return response.messageId;
-    }
-    async sendAndWait(options, timeout) {
-      const effectiveTimeout = timeout ?? 60000;
-      let resolveIdle;
-      let rejectWithError;
-      const idlePromise = new Promise((resolve4, reject) => {
-        resolveIdle = resolve4;
-        rejectWithError = reject;
-      });
-      let lastAssistantMessage;
-      const unsubscribe = this.on((event) => {
-        if (event.type === "assistant.message") {
-          lastAssistantMessage = event;
-        } else if (event.type === "session.idle") {
-          resolveIdle();
-        } else if (event.type === "session.error") {
-          const error2 = new Error(event.data.message);
-          error2.stack = event.data.stack;
-          rejectWithError(error2);
-        }
+  async send(options) {
+    const response = await this.connection.sendRequest("session.send", {
+      sessionId: this.sessionId,
+      prompt: options.prompt,
+      attachments: options.attachments,
+      mode: options.mode
+    });
+    return response.messageId;
+  }
+  async sendAndWait(options, timeout) {
+    const effectiveTimeout = timeout ?? 60000;
+    let resolveIdle;
+    let rejectWithError;
+    const idlePromise = new Promise((resolve4, reject) => {
+      resolveIdle = resolve4;
+      rejectWithError = reject;
+    });
+    let lastAssistantMessage;
+    const unsubscribe = this.on((event) => {
+      if (event.type === "assistant.message") {
+        lastAssistantMessage = event;
+      } else if (event.type === "session.idle") {
+        resolveIdle();
+      } else if (event.type === "session.error") {
+        const error2 = new Error(event.data.message);
+        error2.stack = event.data.stack;
+        rejectWithError(error2);
+      }
+    });
+    let timeoutId;
+    try {
+      await this.send(options);
+      const timeoutPromise = new Promise((_4, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`Timeout after ${effectiveTimeout}ms waiting for session.idle`)), effectiveTimeout);
       });
-      let timeoutId;
-      try {
-        await this.send(options);
-        const timeoutPromise = new Promise((_4, reject) => {
-          timeoutId = setTimeout(() => reject(new Error(`Timeout after ${effectiveTimeout}ms waiting for session.idle`)), effectiveTimeout);
-        });
-        await Promise.race([idlePromise, timeoutPromise]);
-        return lastAssistantMessage;
-      } finally {
-        if (timeoutId !== undefined) {
-          clearTimeout(timeoutId);
-        }
-        unsubscribe();
+      await Promise.race([idlePromise, timeoutPromise]);
+      return lastAssistantMessage;
+    } finally {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
       }
+      unsubscribe();
     }
-    on(eventTypeOrHandler, handler) {
-      if (typeof eventTypeOrHandler === "string" && handler) {
-        const eventType = eventTypeOrHandler;
-        if (!this.typedEventHandlers.has(eventType)) {
-          this.typedEventHandlers.set(eventType, /* @__PURE__ */ new Set);
-        }
-        const storedHandler = handler;
-        this.typedEventHandlers.get(eventType).add(storedHandler);
-        return () => {
-          const handlers = this.typedEventHandlers.get(eventType);
-          if (handlers) {
-            handlers.delete(storedHandler);
-          }
-        };
+  }
+  on(eventTypeOrHandler, handler) {
+    if (typeof eventTypeOrHandler === "string" && handler) {
+      const eventType = eventTypeOrHandler;
+      if (!this.typedEventHandlers.has(eventType)) {
+        this.typedEventHandlers.set(eventType, /* @__PURE__ */ new Set);
       }
-      const wildcardHandler = eventTypeOrHandler;
-      this.eventHandlers.add(wildcardHandler);
+      const storedHandler = handler;
+      this.typedEventHandlers.get(eventType).add(storedHandler);
       return () => {
-        this.eventHandlers.delete(wildcardHandler);
+        const handlers = this.typedEventHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(storedHandler);
+        }
       };
     }
-    _dispatchEvent(event) {
-      this._handleBroadcastEvent(event);
-      const typedHandlers = this.typedEventHandlers.get(event.type);
-      if (typedHandlers) {
-        for (const handler of typedHandlers) {
-          try {
-            handler(event);
-          } catch (_error) {}
-        }
-      }
-      for (const handler of this.eventHandlers) {
+    const wildcardHandler = eventTypeOrHandler;
+    this.eventHandlers.add(wildcardHandler);
+    return () => {
+      this.eventHandlers.delete(wildcardHandler);
+    };
+  }
+  _dispatchEvent(event) {
+    const typedHandlers = this.typedEventHandlers.get(event.type);
+    if (typedHandlers) {
+      for (const handler of typedHandlers) {
         try {
           handler(event);
         } catch (_error) {}
       }
     }
-    _handleBroadcastEvent(event) {
-      if (event.type === "external_tool.requested") {
-        const { requestId, toolName } = event.data;
-        const args = event.data.arguments;
-        const toolCallId = event.data.toolCallId;
-        const traceparent = event.data.traceparent;
-        const tracestate = event.data.tracestate;
-        const handler = this.toolHandlers.get(toolName);
-        if (handler) {
-          this._executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate);
-        }
-      } else if (event.type === "permission.requested") {
-        const { requestId, permissionRequest, resolvedByHook } = event.data;
-        if (resolvedByHook) {
-          return;
-        }
-        if (this.permissionHandler) {
-          this._executePermissionAndRespond(requestId, permissionRequest);
-        }
-      } else if (event.type === "command.execute") {
-        const { requestId, commandName, command, args } = event.data;
-        this._executeCommandAndRespond(requestId, commandName, command, args);
-      } else if (event.type === "elicitation.requested") {
-        if (this.elicitationHandler) {
-          const { message, requestedSchema, mode, elicitationSource, url, requestId } = event.data;
-          this._handleElicitationRequest({
-            sessionId: this.sessionId,
-            message,
-            requestedSchema,
-            mode,
-            elicitationSource,
-            url
-          }, requestId);
-        }
-      } else if (event.type === "capabilities.changed") {
-        this._capabilities = { ...this._capabilities, ...event.data };
-      }
-    }
-    async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
-      try {
-        const rawResult = await handler(args, {
-          sessionId: this.sessionId,
-          toolCallId,
-          toolName,
-          arguments: args,
-          traceparent,
-          tracestate
-        });
-        let result;
-        if (rawResult == null) {
-          result = "";
-        } else if (typeof rawResult === "string") {
-          result = rawResult;
-        } else if (isToolResultObject(rawResult)) {
-          result = rawResult;
-        } else {
-          result = JSON.stringify(rawResult);
-        }
-        await this.rpc.tools.handlePendingToolCall({ requestId, result });
-      } catch (error2) {
-        const message = error2 instanceof Error ? error2.message : String(error2);
-        try {
-          await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
-        } catch (rpcError) {
-          if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
-            throw rpcError;
-          }
-        }
-      }
-    }
-    async _executePermissionAndRespond(requestId, permissionRequest) {
+    for (const handler of this.eventHandlers) {
       try {
-        const result = await this.permissionHandler(permissionRequest, {
-          sessionId: this.sessionId
-        });
-        if (result.kind === "no-result") {
-          return;
-        }
-        await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
-      } catch (_error) {
-        try {
-          await this.rpc.permissions.handlePendingPermissionRequest({
-            requestId,
-            result: {
-              kind: "user-not-available"
-            }
-          });
-        } catch (rpcError) {
-          if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
-            throw rpcError;
-          }
-        }
-      }
-    }
-    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 (error2) {
-        const message = error2 instanceof Error ? error2.message : String(error2);
-        try {
-          await this.rpc.commands.handlePendingCommand({ requestId, error: message });
-        } catch (rpcError) {
-          if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
-            throw rpcError;
-          }
-        }
-      }
-    }
-    registerTools(tools) {
-      this.toolHandlers.clear();
-      if (!tools) {
-        return;
-      }
-      for (const tool of tools) {
-        this.toolHandlers.set(tool.name, tool.handler);
-      }
-    }
-    getToolHandler(name) {
-      return this.toolHandlers.get(name);
-    }
-    registerCommands(commands) {
-      this.commandHandlers.clear();
-      if (!commands) {
-        return;
-      }
-      for (const cmd of commands) {
-        this.commandHandlers.set(cmd.name, cmd.handler);
-      }
-    }
-    registerElicitationHandler(handler) {
-      this.elicitationHandler = handler;
-    }
-    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;
-          }
-        }
-      }
-    }
-    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;
-    }
-    registerPermissionHandler(handler) {
-      this.permissionHandler = handler;
-    }
-    registerUserInputHandler(handler) {
-      this.userInputHandler = handler;
-    }
-    registerHooks(hooks) {
-      this.hooks = hooks;
-    }
-    registerTransformCallbacks(callbacks) {
-      this.transformCallbacks = callbacks;
-    }
-    async _handleSystemMessageTransform(sections) {
-      const result = {};
-      for (const [sectionId, { content }] of Object.entries(sections)) {
-        const callback = this.transformCallbacks?.get(sectionId);
-        if (callback) {
-          try {
-            const transformed = await callback(content);
-            result[sectionId] = { content: transformed };
-          } catch (_error) {
-            result[sectionId] = { content };
-          }
-        } else {
-          result[sectionId] = { content };
-        }
-      }
-      return { sections: result };
-    }
-    async _handlePermissionRequestV2(request) {
-      if (!this.permissionHandler) {
-        return { kind: "user-not-available" };
-      }
-      try {
-        const result = await this.permissionHandler(request, {
-          sessionId: this.sessionId
-        });
-        if (result.kind === "no-result") {
-          throw new Error(NO_RESULT_PERMISSION_V2_ERROR);
-        }
-        return result;
-      } catch (error2) {
-        if (error2 instanceof Error && error2.message === NO_RESULT_PERMISSION_V2_ERROR) {
-          throw error2;
-        }
-        return { kind: "user-not-available" };
-      }
+        handler(event);
+      } catch (_error) {}
     }
-    async _handleUserInputRequest(request) {
-      if (!this.userInputHandler) {
-        throw new Error("User input requested but no handler registered");
-      }
-      try {
-        const result = await this.userInputHandler(request, {
-          sessionId: this.sessionId
-        });
-        return result;
-      } catch (error2) {
-        throw error2;
-      }
+  }
+  registerTools(tools) {
+    this.toolHandlers.clear();
+    if (!tools) {
+      return;
     }
-    async _handleHooksInvoke(hookType, input) {
-      if (!this.hooks) {
-        return;
-      }
-      const handlerMap = {
-        preToolUse: this.hooks.onPreToolUse,
-        postToolUse: this.hooks.onPostToolUse,
-        userPromptSubmitted: this.hooks.onUserPromptSubmitted,
-        sessionStart: this.hooks.onSessionStart,
-        sessionEnd: this.hooks.onSessionEnd,
-        errorOccurred: this.hooks.onErrorOccurred
-      };
-      const handler = handlerMap[hookType];
-      if (!handler) {
-        return;
-      }
-      try {
-        const result = await handler(input, { sessionId: this.sessionId });
-        return result;
-      } catch (_error) {
-        return;
-      }
+    for (const tool of tools) {
+      this.toolHandlers.set(tool.name, tool.handler);
     }
-    async getMessages() {
-      const response = await this.connection.sendRequest("session.getMessages", {
-        sessionId: this.sessionId
-      });
-      return response.events;
+  }
+  getToolHandler(name) {
+    return this.toolHandlers.get(name);
+  }
+  registerPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  registerUserInputHandler(handler) {
+    this.userInputHandler = handler;
+  }
+  registerHooks(hooks) {
+    this.hooks = hooks;
+  }
+  async _handlePermissionRequest(request) {
+    if (!this.permissionHandler) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
     }
-    async disconnect() {
-      await this.connection.sendRequest("session.destroy", {
+    try {
+      const result = await this.permissionHandler(request, {
         sessionId: this.sessionId
       });
-      this.eventHandlers.clear();
-      this.typedEventHandlers.clear();
-      this.toolHandlers.clear();
-      this.permissionHandler = undefined;
-    }
-    async destroy() {
-      return this.disconnect();
+      return result;
+    } catch (_error) {
+      return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
     }
-    async[Symbol.asyncDispose]() {
-      return this.disconnect();
+  }
+  async _handleUserInputRequest(request) {
+    if (!this.userInputHandler) {
+      throw new Error("User input requested but no handler registered");
     }
-    async abort() {
-      await this.connection.sendRequest("session.abort", {
+    try {
+      const result = await this.userInputHandler(request, {
         sessionId: this.sessionId
       });
+      return result;
+    } catch (error2) {
+      throw error2;
     }
-    async setModel(model, options) {
-      await this.rpc.model.switchTo({ modelId: model, ...options });
-    }
-    async log(message, options) {
-      await this.rpc.log({ message, ...options });
+  }
+  async _handleHooksInvoke(hookType, input) {
+    if (!this.hooks) {
+      return;
     }
-  };
-});
-
-// node_modules/@github/copilot-sdk/dist/sessionFsProvider.js
-function createSessionFsAdapter(provider) {
-  return {
-    readFile: async ({ path: path2 }) => {
-      try {
-        const content = await provider.readFile(path2);
-        return { content };
-      } catch (err) {
-        return { content: "", error: toSessionFsError(err) };
-      }
-    },
-    writeFile: async ({ path: path2, content, mode }) => {
-      try {
-        await provider.writeFile(path2, content, mode);
-        return;
-      } catch (err) {
-        return toSessionFsError(err);
-      }
-    },
-    appendFile: async ({ path: path2, content, mode }) => {
-      try {
-        await provider.appendFile(path2, content, mode);
-        return;
-      } catch (err) {
-        return toSessionFsError(err);
-      }
-    },
-    exists: async ({ path: path2 }) => {
-      try {
-        return { exists: await provider.exists(path2) };
-      } catch {
-        return { exists: false };
-      }
-    },
-    stat: async ({ path: path2 }) => {
-      try {
-        return await provider.stat(path2);
-      } 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: path2, recursive, mode }) => {
-      try {
-        await provider.mkdir(path2, recursive ?? false, mode);
-        return;
-      } catch (err) {
-        return toSessionFsError(err);
-      }
-    },
-    readdir: async ({ path: path2 }) => {
-      try {
-        const entries = await provider.readdir(path2);
-        return { entries };
-      } catch (err) {
-        return { entries: [], error: toSessionFsError(err) };
-      }
-    },
-    readdirWithTypes: async ({ path: path2 }) => {
-      try {
-        const entries = await provider.readdirWithTypes(path2);
-        return { entries };
-      } catch (err) {
-        return { entries: [], error: toSessionFsError(err) };
-      }
-    },
-    rm: async ({ path: path2, recursive, force }) => {
-      try {
-        await provider.rm(path2, recursive ?? false, force ?? false);
-        return;
-      } catch (err) {
-        return toSessionFsError(err);
-      }
-    },
-    rename: async ({ src: src2, dest }) => {
-      try {
-        await provider.rename(src2, dest);
-        return;
-      } catch (err) {
-        return toSessionFsError(err);
-      }
+    const handlerMap = {
+      preToolUse: this.hooks.onPreToolUse,
+      postToolUse: this.hooks.onPostToolUse,
+      userPromptSubmitted: this.hooks.onUserPromptSubmitted,
+      sessionStart: this.hooks.onSessionStart,
+      sessionEnd: this.hooks.onSessionEnd,
+      errorOccurred: this.hooks.onErrorOccurred
+    };
+    const handler = handlerMap[hookType];
+    if (!handler) {
+      return;
     }
-  };
-}
-function toSessionFsError(err) {
-  const e3 = err;
-  const code = e3.code === "ENOENT" ? "ENOENT" : "UNKNOWN";
-  return { code, message: e3.message ?? String(err) };
-}
-var init_sessionFsProvider = () => {};
-
-// node_modules/@github/copilot-sdk/dist/types.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;
-      }
+    try {
+      const result = await handler(input, { sessionId: this.sessionId });
+      return result;
+    } catch (_error) {
+      return;
     }
   }
-  return {
-    textResultForLlm: textParts.join(`
-`),
-    resultType: callResult.isError ? "failure" : "success",
-    ...binaryResults.length > 0 ? { binaryResultsForLlm: binaryResults } : {}
-  };
-}
-function defineTool(name, config) {
-  return { name, ...config };
+  async getMessages() {
+    const response = await this.connection.sendRequest("session.getMessages", {
+      sessionId: this.sessionId
+    });
+    return response.events;
+  }
+  async destroy() {
+    await this.connection.sendRequest("session.destroy", {
+      sessionId: this.sessionId
+    });
+    this.eventHandlers.clear();
+    this.typedEventHandlers.clear();
+    this.toolHandlers.clear();
+    this.permissionHandler = undefined;
+  }
+  async abort() {
+    await this.connection.sendRequest("session.abort", {
+      sessionId: this.sessionId
+    });
+  }
 }
-var SYSTEM_PROMPT_SECTIONS, approveAll = () => ({ kind: "approve-once" }), defaultJoinSessionPermissionHandler = () => ({
-  kind: "no-result"
-});
-var init_types2 = __esm(() => {
-  init_sessionFsProvider();
-  SYSTEM_PROMPT_SECTIONS = {
-    identity: { description: "Agent identity preamble and mode statement" },
-    tone: { description: "Response style, conciseness rules, output formatting preferences" },
-    tool_efficiency: { description: "Tool usage patterns, parallel calling, batching guidelines" },
-    environment_context: { description: "CWD, OS, git root, directory listing, available tools" },
-    code_change_rules: { description: "Coding rules, linting/testing, ecosystem tools, style" },
-    guidelines: { description: "Tips, behavioral best practices, behavioral guidelines" },
-    safety: { description: "Environment limitations, prohibited actions, security policies" },
-    tool_instructions: { description: "Per-tool usage instructions" },
-    custom_instructions: { description: "Repository and organization custom instructions" },
-    last_instructions: {
-      description: "End-of-prompt instructions: parallel tool calling, persistence, task completion"
-    }
-  };
+var init_session = __esm(() => {
+  init_rpc();
 });
 
 // node_modules/@github/copilot-sdk/dist/client.js
 import { spawn } from "child_process";
-import { randomUUID } from "crypto";
 import { existsSync as existsSync4 } from "fs";
-import { createRequire } from "module";
 import { Socket } from "net";
 import { dirname as dirname4, join as join4 } from "path";
 import { fileURLToPath } from "url";
@@ -7330,31 +6686,6 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
-function extractTransformCallbacks(systemMessage) {
-  if (!systemMessage || systemMessage.mode !== "customize" || !systemMessage.sections) {
-    return { wirePayload: systemMessage, transformCallbacks: undefined };
-  }
-  const transformCallbacks = /* @__PURE__ */ new Map;
-  const wireSections = {};
-  for (const [sectionId, override] of Object.entries(systemMessage.sections)) {
-    if (!override)
-      continue;
-    if (typeof override.action === "function") {
-      transformCallbacks.set(sectionId, override.action);
-      wireSections[sectionId] = { action: "transform" };
-    } else {
-      wireSections[sectionId] = { action: override.action, content: override.content };
-    }
-  }
-  if (transformCallbacks.size === 0) {
-    return { wirePayload: systemMessage, transformCallbacks: undefined };
-  }
-  const wirePayload = {
-    ...systemMessage,
-    sections: wireSections
-  };
-  return { wirePayload, transformCallbacks };
-}
 function getNodeExecPath() {
   if (process.versions.bun) {
     return "node";
@@ -7362,24 +6693,12 @@ function getNodeExecPath() {
   return process.execPath;
 }
 function getBundledCliPath() {
-  if (typeof import.meta.resolve === "function") {
-    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-    const sdkPath = fileURLToPath(sdkUrl);
-    return join4(dirname4(dirname4(sdkPath)), "index.js");
-  }
-  const req = createRequire(__filename);
-  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
-  for (const base of searchPaths) {
-    const candidate = join4(base, "@github", "copilot", "index.js");
-    if (existsSync4(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(`Could not find @github/copilot package. Searched ${searchPaths.length} paths. Ensure it is installed, or pass cliPath/cliUrl to CopilotClient.`);
+  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+  const sdkPath = fileURLToPath(sdkUrl);
+  return join4(dirname4(dirname4(sdkPath)), "index.js");
 }
 
 class CopilotClient {
-  cliStartTimeout = null;
   cliProcess = null;
   connection = null;
   socket = null;
@@ -7391,16 +6710,12 @@ class CopilotClient {
   options;
   isExternalServer = false;
   forceStopping = false;
-  onListModels;
-  onGetTraceContext;
   modelsCache = null;
   modelsCacheLock = Promise.resolve();
   sessionLifecycleHandlers = /* @__PURE__ */ new Set;
   typedLifecycleHandlers = /* @__PURE__ */ new Map;
   _rpc = null;
   processExitPromise = null;
-  negotiatedProtocolVersion = null;
-  sessionFsConfig = null;
   get rpc() {
     if (!this.connection) {
       throw new Error("Client is not connected. Call start() first.");
@@ -7414,14 +6729,8 @@ class CopilotClient {
     if (options.cliUrl && (options.useStdio === true || options.cliPath)) {
       throw new Error("cliUrl is mutually exclusive with useStdio and cliPath");
     }
-    if (options.isChildProcess && (options.cliUrl || options.useStdio === false)) {
-      throw new Error("isChildProcess must be used in conjunction with useStdio and not with cliUrl");
-    }
-    if (options.cliUrl && (options.gitHubToken || options.useLoggedInUser !== undefined)) {
-      throw new Error("gitHubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)");
-    }
-    if (options.sessionFs) {
-      this.validateSessionFsConfig(options.sessionFs);
+    if (options.cliUrl && (options.githubToken || options.useLoggedInUser !== undefined)) {
+      throw new Error("githubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)");
     }
     if (options.cliUrl) {
       const { host, port } = this.parseCliUrl(options.cliUrl);
@@ -7429,29 +6738,19 @@ class CopilotClient {
       this.actualPort = port;
       this.isExternalServer = true;
     }
-    if (options.isChildProcess) {
-      this.isExternalServer = true;
-    }
-    this.onListModels = options.onListModels;
-    this.onGetTraceContext = options.onGetTraceContext;
-    this.sessionFsConfig = options.sessionFs ?? null;
-    const effectiveEnv = options.env ?? process.env;
     this.options = {
-      cliPath: options.cliUrl ? undefined : options.cliPath || effectiveEnv.COPILOT_CLI_PATH || getBundledCliPath(),
+      cliPath: options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
       cwd: options.cwd ?? process.cwd(),
       port: options.port || 0,
       useStdio: options.cliUrl ? false : options.useStdio ?? true,
-      isChildProcess: options.isChildProcess ?? false,
       cliUrl: options.cliUrl,
       logLevel: options.logLevel || "debug",
       autoStart: options.autoStart ?? true,
-      autoRestart: false,
-      env: effectiveEnv,
-      gitHubToken: options.gitHubToken,
-      useLoggedInUser: options.useLoggedInUser ?? (options.gitHubToken ? false : true),
-      telemetry: options.telemetry,
-      sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0
+      autoRestart: options.autoRestart ?? true,
+      env: options.env ?? process.env,
+      githubToken: options.githubToken,
+      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true)
     };
   }
   parseCliUrl(url) {
@@ -7470,17 +6769,6 @@ class CopilotClient {
     }
     return { host, port };
   }
-  validateSessionFsConfig(config) {
-    if (!config.initialCwd) {
-      throw new Error("sessionFs.initialCwd is required");
-    }
-    if (!config.sessionStatePath) {
-      throw new Error("sessionFs.sessionStatePath is required");
-    }
-    if (config.conventions !== "windows" && config.conventions !== "posix") {
-      throw new Error("sessionFs.conventions must be either 'windows' or 'posix'");
-    }
-  }
   async start() {
     if (this.state === "connected") {
       return;
@@ -7492,13 +6780,6 @@ class CopilotClient {
       }
       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 (error2) {
       this.state = "error";
@@ -7512,7 +6793,7 @@ class CopilotClient {
       let lastError = null;
       for (let attempt = 1;attempt <= 3; attempt++) {
         try {
-          await session.disconnect();
+          await session.destroy();
           lastError = null;
           break;
         } catch (error2) {
@@ -7524,7 +6805,7 @@ class CopilotClient {
         }
       }
       if (lastError) {
-        errors.push(new Error(`Failed to disconnect session ${sessionId} after 3 attempts: ${lastError.message}`));
+        errors.push(new Error(`Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`));
       }
     }
     this.sessions.clear();
@@ -7554,10 +6835,6 @@ class CopilotClient {
       }
       this.cliProcess = null;
     }
-    if (this.cliStartTimeout) {
-      clearTimeout(this.cliStartTimeout);
-      this.cliStartTimeout = null;
-    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
@@ -7587,19 +6864,12 @@ class CopilotClient {
       } catch {}
       this.cliProcess = null;
     }
-    if (this.cliStartTimeout) {
-      clearTimeout(this.cliStartTimeout);
-      this.cliStartTimeout = null;
-    }
     this.state = "disconnected";
     this.actualPort = null;
     this.stderrBuffer = "";
     this.processExitPromise = null;
   }
-  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 }.");
-    }
+  async createSession(config = {}) {
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -7607,90 +6877,49 @@ class CopilotClient {
         throw new Error("Client not connected. Call start() first.");
       }
     }
-    const sessionId = config.sessionId ?? randomUUID();
-    const session = new CopilotSession(sessionId, this.connection, undefined, this.onGetTraceContext);
+    const response = await this.connection.sendRequest("session.create", {
+      model: config.model,
+      sessionId: config.sessionId,
+      clientName: config.clientName,
+      reasoningEffort: config.reasoningEffort,
+      tools: config.tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: toJsonSchema(tool.parameters)
+      })),
+      systemMessage: config.systemMessage,
+      availableTools: config.availableTools,
+      excludedTools: config.excludedTools,
+      provider: config.provider,
+      requestPermission: true,
+      requestUserInput: !!config.onUserInputRequest,
+      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+      workingDirectory: config.workingDirectory,
+      streaming: config.streaming,
+      mcpServers: config.mcpServers,
+      envValueMode: "direct",
+      customAgents: config.customAgents,
+      configDir: config.configDir,
+      skillDirectories: config.skillDirectories,
+      disabledSkills: config.disabledSkills,
+      infiniteSessions: config.infiniteSessions
+    });
+    const { sessionId, workspacePath } = response;
+    const session = new CopilotSession(sessionId, this.connection, workspacePath);
     session.registerTools(config.tools);
-    session.registerCommands(config.commands);
-    session.registerPermissionHandler(config.onPermissionRequest);
+    if (config.onPermissionRequest) {
+      session.registerPermissionHandler(config.onPermissionRequest);
+    }
     if (config.onUserInputRequest) {
       session.registerUserInputHandler(config.onUserInputRequest);
     }
-    if (config.onElicitationRequest) {
-      session.registerElicitationHandler(config.onElicitationRequest);
-    }
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
-    const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(config.systemMessage);
-    if (transformCallbacks) {
-      session.registerTransformCallbacks(transformCallbacks);
-    }
-    if (config.onEvent) {
-      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.");
-      }
-    }
-    try {
-      const response = await this.connection.sendRequest("session.create", {
-        ...await getTraceContext(this.onGetTraceContext),
-        model: config.model,
-        sessionId,
-        clientName: config.clientName,
-        reasoningEffort: config.reasoningEffort,
-        tools: config.tools?.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
-          overridesBuiltInTool: tool.overridesBuiltInTool,
-          skipPermission: tool.skipPermission
-        })),
-        commands: config.commands?.map((cmd) => ({
-          name: cmd.name,
-          description: cmd.description
-        })),
-        systemMessage: wireSystemMessage,
-        availableTools: config.availableTools,
-        excludedTools: config.excludedTools,
-        provider: config.provider,
-        modelCapabilities: config.modelCapabilities,
-        requestPermission: true,
-        requestUserInput: !!config.onUserInputRequest,
-        requestElicitation: !!config.onElicitationRequest,
-        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,
-        gitHubToken: config.gitHubToken
-      });
-      const { workspacePath, capabilities } = response;
-      session["_workspacePath"] = workspacePath;
-      session.setCapabilities(capabilities);
-    } catch (e3) {
-      this.sessions.delete(sessionId);
-      throw e3;
-    }
     return session;
   }
-  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 }.");
-    }
+  async resumeSession(sessionId, config = {}) {
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -7698,84 +6927,47 @@ class CopilotClient {
         throw new Error("Client not connected. Call start() first.");
       }
     }
-    const session = new CopilotSession(sessionId, this.connection, undefined, this.onGetTraceContext);
+    const response = await this.connection.sendRequest("session.resume", {
+      sessionId,
+      clientName: config.clientName,
+      model: config.model,
+      reasoningEffort: config.reasoningEffort,
+      systemMessage: config.systemMessage,
+      availableTools: config.availableTools,
+      excludedTools: config.excludedTools,
+      tools: config.tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: toJsonSchema(tool.parameters)
+      })),
+      provider: config.provider,
+      requestPermission: true,
+      requestUserInput: !!config.onUserInputRequest,
+      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+      workingDirectory: config.workingDirectory,
+      configDir: config.configDir,
+      streaming: config.streaming,
+      mcpServers: config.mcpServers,
+      envValueMode: "direct",
+      customAgents: config.customAgents,
+      skillDirectories: config.skillDirectories,
+      disabledSkills: config.disabledSkills,
+      infiniteSessions: config.infiniteSessions,
+      disableResume: config.disableResume
+    });
+    const { sessionId: resumedSessionId, workspacePath } = response;
+    const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
     session.registerTools(config.tools);
-    session.registerCommands(config.commands);
-    session.registerPermissionHandler(config.onPermissionRequest);
+    if (config.onPermissionRequest) {
+      session.registerPermissionHandler(config.onPermissionRequest);
+    }
     if (config.onUserInputRequest) {
       session.registerUserInputHandler(config.onUserInputRequest);
     }
-    if (config.onElicitationRequest) {
-      session.registerElicitationHandler(config.onElicitationRequest);
-    }
     if (config.hooks) {
       session.registerHooks(config.hooks);
     }
-    const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(config.systemMessage);
-    if (transformCallbacks) {
-      session.registerTransformCallbacks(transformCallbacks);
-    }
-    if (config.onEvent) {
-      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.");
-      }
-    }
-    try {
-      const response = await this.connection.sendRequest("session.resume", {
-        ...await getTraceContext(this.onGetTraceContext),
-        sessionId,
-        clientName: config.clientName,
-        model: config.model,
-        reasoningEffort: config.reasoningEffort,
-        systemMessage: wireSystemMessage,
-        availableTools: config.availableTools,
-        excludedTools: config.excludedTools,
-        tools: config.tools?.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
-          overridesBuiltInTool: tool.overridesBuiltInTool,
-          skipPermission: tool.skipPermission
-        })),
-        commands: config.commands?.map((cmd) => ({
-          name: cmd.name,
-          description: cmd.description
-        })),
-        provider: config.provider,
-        modelCapabilities: config.modelCapabilities,
-        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,
-        infiniteSessions: config.infiniteSessions,
-        disableResume: config.disableResume,
-        gitHubToken: config.gitHubToken
-      });
-      const { workspacePath, capabilities } = response;
-      session["_workspacePath"] = workspacePath;
-      session.setCapabilities(capabilities);
-    } catch (e3) {
-      this.sessions.delete(sessionId);
-      throw e3;
-    }
+    this.sessions.set(resumedSessionId, session);
     return session;
   }
   getState() {
@@ -7803,6 +6995,9 @@ class CopilotClient {
     return result;
   }
   async listModels() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
     await this.modelsCacheLock;
     let resolveLock;
     this.modelsCacheLock = new Promise((resolve4) => {
@@ -7812,42 +7007,17 @@ class CopilotClient {
       if (this.modelsCache !== null) {
         return [...this.modelsCache];
       }
-      let models;
-      if (this.onListModels) {
-        models = await this.onListModels();
-      } else {
-        if (!this.connection) {
-          throw new Error("Client not connected");
-        }
-        const result = await this.connection.sendRequest("models.list", {});
-        const response = result;
-        models = response.models;
-        for (const model of models) {
-          const m2 = model;
-          if (!m2.capabilities) {
-            m2.capabilities = {
-              supports: {},
-              limits: { max_context_window_tokens: 0 }
-            };
-          } else {
-            if (!m2.capabilities.supports)
-              m2.capabilities.supports = {};
-            if (!m2.capabilities.limits) {
-              m2.capabilities.limits = { max_context_window_tokens: 0 };
-            } else if (m2.capabilities.limits.max_context_window_tokens === undefined) {
-              m2.capabilities.limits.max_context_window_tokens = 0;
-            }
-          }
-        }
-      }
-      this.modelsCache = [...models];
+      const result = await this.connection.sendRequest("models.list", {});
+      const response = result;
+      const models = response.models;
+      this.modelsCache = models;
       return [...models];
     } finally {
       resolveLock();
     }
   }
   async verifyProtocolVersion() {
-    const maxVersion = getSdkProtocolVersion();
+    const expectedVersion = getSdkProtocolVersion();
     let pingResult;
     if (this.processExitPromise) {
       pingResult = await Promise.race([this.ping(), this.processExitPromise]);
@@ -7856,12 +7026,11 @@ class CopilotClient {
     }
     const serverVersion = pingResult.protocolVersion;
     if (serverVersion === undefined) {
-      throw new Error(`SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`);
+      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`);
     }
-    if (serverVersion < MIN_PROTOCOL_VERSION || serverVersion > maxVersion) {
-      throw new Error(`SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`);
+    if (serverVersion !== expectedVersion) {
+      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`);
     }
-    this.negotiatedProtocolVersion = serverVersion;
   }
   async getLastSessionId() {
     if (!this.connection) {
@@ -7887,32 +7056,16 @@ class CopilotClient {
     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(CopilotClient.toSessionMetadata);
-  }
-  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;
-    }
-    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
-    };
+    return sessions.map((s2) => ({
+      sessionId: s2.sessionId,
+      startTime: new Date(s2.startTime),
+      modifiedTime: new Date(s2.modifiedTime),
+      summary: s2.summary,
+      isRemote: s2.isRemote,
+      context: s2.context
+    }));
   }
   async getForegroundSessionId() {
     if (!this.connection) {
@@ -7967,36 +7120,16 @@ 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 !== undefined && 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.cliPath) {
-        throw new Error("Path to Copilot CLI is required. Please provide it via the cliPath option, or use cliUrl to rely on a remote CLI.");
-      }
-      if (this.options.telemetry) {
-        const t2 = this.options.telemetry;
-        envWithoutNodeDebug.COPILOT_OTEL_ENABLED = "true";
-        if (t2.otlpEndpoint !== undefined)
-          envWithoutNodeDebug.OTEL_EXPORTER_OTLP_ENDPOINT = t2.otlpEndpoint;
-        if (t2.filePath !== undefined)
-          envWithoutNodeDebug.COPILOT_OTEL_FILE_EXPORTER_PATH = t2.filePath;
-        if (t2.exporterType !== undefined)
-          envWithoutNodeDebug.COPILOT_OTEL_EXPORTER_TYPE = t2.exporterType;
-        if (t2.sourceName !== undefined)
-          envWithoutNodeDebug.COPILOT_OTEL_SOURCE_NAME = t2.sourceName;
-        if (t2.captureContent !== undefined)
-          envWithoutNodeDebug.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = String(t2.captureContent);
+      if (this.options.githubToken) {
+        envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.githubToken;
       }
       if (!existsSync4(this.options.cliPath)) {
         throw new Error(`Copilot CLI not found at ${this.options.cliPath}. Ensure @github/copilot is installed.`);
@@ -8081,9 +7214,11 @@ stderr: ${stderrOutput}`));
           } else {
             reject(new Error(`CLI server exited with code ${code}`));
           }
+        } else if (this.options.autoRestart && this.state === "connected") {
+          this.reconnect();
         }
       });
-      this.cliStartTimeout = setTimeout(() => {
+      setTimeout(() => {
         if (!resolved) {
           resolved = true;
           reject(new Error("Timeout waiting for CLI server to start"));
@@ -8092,15 +7227,13 @@ stderr: ${stderrOutput}`));
     });
   }
   async connectToServer() {
-    if (this.options.isChildProcess) {
-      return this.connectToParentProcessViaStdio();
-    } else if (this.options.useStdio) {
-      return this.connectToChildProcessViaStdio();
+    if (this.options.useStdio) {
+      return this.connectViaStdio();
     } else {
       return this.connectViaTcp();
     }
   }
-  async connectToChildProcessViaStdio() {
+  async connectViaStdio() {
     if (!this.cliProcess) {
       throw new Error("CLI process not started");
     }
@@ -8109,15 +7242,7 @@ stderr: ${stderrOutput}`));
         throw err;
       }
     });
-    this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(this.cliProcess.stdout), new import_node2.StreamMessageWriter(this.cliProcess.stdin));
-    this.attachConnectionHandlers();
-    this.connection.listen();
-  }
-  async connectToParentProcessViaStdio() {
-    if (this.cliProcess) {
-      throw new Error("CLI child process was unexpectedly started in parent process mode");
-    }
-    this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(process.stdin), new import_node2.StreamMessageWriter(process.stdout));
+    this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.cliProcess.stdout), new import_node.StreamMessageWriter(this.cliProcess.stdin));
     this.attachConnectionHandlers();
     this.connection.listen();
   }
@@ -8128,7 +7253,7 @@ stderr: ${stderrOutput}`));
     return new Promise((resolve4, reject) => {
       this.socket = new Socket;
       this.socket.connect(this.actualPort, this.actualHost, () => {
-        this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(this.socket), new import_node2.StreamMessageWriter(this.socket));
+        this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.socket), new import_node.StreamMessageWriter(this.socket));
         this.attachConnectionHandlers();
         this.connection.listen();
         resolve4();
@@ -8148,24 +7273,16 @@ stderr: ${stderrOutput}`));
     this.connection.onNotification("session.lifecycle", (notification) => {
       this.handleSessionLifecycleNotification(notification);
     });
-    this.connection.onRequest("tool.call", async (params) => await this.handleToolCallRequestV2(params));
-    this.connection.onRequest("permission.request", async (params) => await this.handlePermissionRequestV2(params));
+    this.connection.onRequest("tool.call", async (params) => await this.handleToolCallRequest(params));
+    this.connection.onRequest("permission.request", async (params) => await this.handlePermissionRequest(params));
     this.connection.onRequest("userInput.request", async (params) => await this.handleUserInputRequest(params));
     this.connection.onRequest("hooks.invoke", async (params) => await this.handleHooksInvoke(params));
-    this.connection.onRequest("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";
-    });
-    this.connection.onError((_error) => {
-      this.state = "disconnected";
+      if (this.state === "connected" && this.options.autoRestart) {
+        this.reconnect();
+      }
     });
+    this.connection.onError((_error) => {});
   }
   handleSessionEventNotification(notification) {
     if (typeof notification !== "object" || !notification || !("sessionId" in notification) || typeof notification.sessionId !== "string" || !("event" in notification)) {
@@ -8195,43 +7312,7 @@ stderr: ${stderrOutput}`));
       } catch {}
     }
   }
-  async handleUserInputRequest(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
-      throw new Error("Invalid user input request payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    const result = await session._handleUserInputRequest({
-      question: params.question,
-      choices: params.choices,
-      allowFreeform: params.allowFreeform
-    });
-    return result;
-  }
-  async handleHooksInvoke(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
-      throw new Error("Invalid hooks invoke payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    const output = await session._handleHooksInvoke(params.hookType, params.input);
-    return { output };
-  }
-  async handleSystemMessageTransform(params) {
-    if (!params || typeof params.sessionId !== "string" || !params.sections || typeof params.sections !== "object") {
-      throw new Error("Invalid systemMessage.transform payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    return await session._handleSystemMessageTransform(params.sections);
-  }
-  async handleToolCallRequestV2(params) {
+  async handleToolCallRequest(params) {
     if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
       throw new Error("Invalid tool call payload");
     }
@@ -8241,28 +7322,20 @@ stderr: ${stderrOutput}`));
     }
     const handler = session.getToolHandler(params.toolName);
     if (!handler) {
-      return {
-        result: {
-          textResultForLlm: `Tool '${params.toolName}' is not supported by this client instance.`,
-          resultType: "failure",
-          error: `tool '${params.toolName}' not supported`,
-          toolTelemetry: {}
-        }
-      };
+      return { result: this.buildUnsupportedToolResult(params.toolName) };
     }
+    return await this.executeToolCall(handler, params);
+  }
+  async executeToolCall(handler, request) {
     try {
-      const traceparent = params.traceparent;
-      const tracestate = params.tracestate;
       const invocation = {
-        sessionId: params.sessionId,
-        toolCallId: params.toolCallId,
-        toolName: params.toolName,
-        arguments: params.arguments,
-        traceparent,
-        tracestate
+        sessionId: request.sessionId,
+        toolCallId: request.toolCallId,
+        toolName: request.toolName,
+        arguments: request.arguments
       };
-      const result = await handler(params.arguments, invocation);
-      return { result: this.normalizeToolResultV2(result) };
+      const result = await handler(request.arguments, invocation);
+      return { result: this.normalizeToolResult(result) };
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       return {
@@ -8275,7 +7348,7 @@ stderr: ${stderrOutput}`));
       };
     }
   }
-  async handlePermissionRequestV2(params) {
+  async handlePermissionRequest(params) {
     if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
       throw new Error("Invalid permission request payload");
     }
@@ -8284,20 +7357,43 @@ stderr: ${stderrOutput}`));
       throw new Error(`Session not found: ${params.sessionId}`);
     }
     try {
-      const result = await session._handlePermissionRequestV2(params.permissionRequest);
+      const result = await session._handlePermissionRequest(params.permissionRequest);
       return { result };
-    } catch (error2) {
-      if (error2 instanceof Error && error2.message === NO_RESULT_PERMISSION_V2_ERROR) {
-        throw error2;
-      }
+    } catch (_error) {
       return {
         result: {
-          kind: "user-not-available"
+          kind: "denied-no-approval-rule-and-could-not-request-from-user"
         }
       };
     }
   }
-  normalizeToolResultV2(result) {
+  async handleUserInputRequest(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
+      throw new Error("Invalid user input request payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const result = await session._handleUserInputRequest({
+      question: params.question,
+      choices: params.choices,
+      allowFreeform: params.allowFreeform
+    });
+    return result;
+  }
+  async handleHooksInvoke(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
+      throw new Error("Invalid hooks invoke payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const output = await session._handleHooksInvoke(params.hookType, params.input);
+    return { output };
+  }
+  normalizeToolResult(result) {
     if (result === undefined || result === null) {
       return {
         textResultForLlm: "Tool returned no result",
@@ -8319,26 +7415,42 @@ stderr: ${stderrOutput}`));
   isToolResultObject(value) {
     return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
   }
+  buildUnsupportedToolResult(toolName) {
+    return {
+      textResultForLlm: `Tool '${toolName}' is not supported by this client instance.`,
+      resultType: "failure",
+      error: `tool '${toolName}' not supported`,
+      toolTelemetry: {}
+    };
+  }
+  async reconnect() {
+    this.state = "disconnected";
+    try {
+      await this.stop();
+      await this.start();
+    } catch (_error) {}
+  }
 }
-var import_node2, __filename = "/home/runner/work/contribute-now/contribute-now/node_modules/@github/copilot-sdk/dist/client.js", MIN_PROTOCOL_VERSION = 2;
+var import_node;
 var init_client = __esm(() => {
   init_rpc();
   init_sdkProtocolVersion();
   init_session();
-  init_sessionFsProvider();
-  init_telemetry();
-  init_types2();
-  import_node2 = __toESM(require_main(), 1);
+  import_node = __toESM(require_main(), 1);
 });
 
+// node_modules/@github/copilot-sdk/dist/types.js
+function defineTool(name, config) {
+  return { name, ...config };
+}
+var approveAll = () => ({ kind: "approved" });
+var init_types2 = () => {};
+
 // node_modules/@github/copilot-sdk/dist/index.js
 var exports_dist2 = {};
 __export(exports_dist2, {
   defineTool: () => defineTool,
-  createSessionFsAdapter: () => createSessionFsAdapter,
-  convertMcpCallToolResult: () => convertMcpCallToolResult,
   approveAll: () => approveAll,
-  SYSTEM_PROMPT_SECTIONS: () => SYSTEM_PROMPT_SECTIONS,
   CopilotSession: () => CopilotSession,
   CopilotClient: () => CopilotClient
 });
@@ -14654,7 +13766,7 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.10.0-patch.647137a",
+  version: "0.10.0",
   description: "Developer CLI that automates git workflows \u2014 branching, syncing, committing, and PRs \u2014 with multi-workflow and commit convention support.",
   type: "module",
   bin: {
@@ -14700,7 +13812,7 @@ var package_default = {
   },
   dependencies: {
     "@clack/prompts": "^1.0.1",
-    "@github/copilot-sdk": "^0.3.0",
+    "@github/copilot-sdk": "^0.1.25",
     "@wgtechlabs/log-engine": "^2.3.1",
     citty: "^0.1.6",
     picocolors: "^1.1.1"