@github/copilot-language-server 1.551.2 → 1.551.3

package/dist/node_modules/@github/copilot-sdk/dist/cjs/copilotRequestHandler.js

@@ -27,6 +27,7 @@ __export(copilotRequestHandler_exports, {
 module.exports = __toCommonJS(copilotRequestHandler_exports);
 const sharedTextDecoder = new TextDecoder("utf-8", { fatal: false });
 const sharedTextEncoder = new TextEncoder();
+const HTTP_RESPONSE_READ_AHEAD_BYTES = 32 * 1024;
 const kBridge = /* @__PURE__ */ Symbol("copilotWebSocketResponseBridge");
 const kCompletion = /* @__PURE__ */ Symbol("copilotWebSocketCompletion");
 const kOpen = /* @__PURE__ */ Symbol("copilotWebSocketOpen");
@@ -265,7 +266,9 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
       const message = err instanceof Error ? err.message : String(err);
       await finalize(exchange, 502, message);
     } finally {
-      pending.delete(exchange.requestId);
+      if (pending.get(exchange.requestId) === exchange) {
+        pending.delete(exchange.requestId);
+      }
     }
   }
   return {
@@ -278,6 +281,13 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
     async httpRequestChunk(params) {
       routeChunk(getOrCreate(params.requestId), params);
       return {};
+    },
+    cancelPending() {
+      const exchanges = [...pending.values()];
+      pending.clear();
+      for (const exchange of exchanges) {
+        exchange.pushCancel("RPC connection closed");
+      }
     }
   };
 }
@@ -526,30 +536,156 @@ async function drainAsync(stream) {
   return out;
 }
 async function streamResponse(response, exchange) {
-  await exchange.startResponse({
-    status: response.status,
-    statusText: response.statusText || void 0,
-    headers: headersToMultiMap(response.headers)
-  });
-  const body = response.body;
-  if (!body) {
-    await exchange.endResponse();
-    return;
-  }
-  const reader = body.getReader();
+  const reader = response.body ? new HttpResponseReader(response.body, exchange.signal) : void 0;
   try {
-    for (; ; ) {
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      if (value && value.byteLength > 0) {
-        await exchange.writeResponse(value);
+    await exchange.startResponse({
+      status: response.status,
+      statusText: response.statusText || void 0,
+      headers: headersToMultiMap(response.headers)
+    });
+    if (reader) {
+      for (; ; ) {
+        const chunk = await reader.nextChunk();
+        if (!chunk) {
+          break;
+        }
+        await exchange.writeResponse(chunk);
       }
     }
     await exchange.endResponse();
   } finally {
-    reader.releaseLock();
+    await reader?.dispose();
+  }
+}
+class HttpResponseReader {
+  #reader;
+  #signal;
+  #frames = [];
+  #pump;
+  #onAbort;
+  #queued = 0;
+  #done = false;
+  #cancelled = false;
+  #hasError = false;
+  #error;
+  #dataWaker;
+  #spaceWaker;
+  #cancelPromise;
+  constructor(body, signal) {
+    this.#reader = body.getReader();
+    this.#signal = signal;
+    this.#onAbort = () => {
+      void this.cancel(signal.reason);
+    };
+    signal.addEventListener("abort", this.#onAbort, { once: true });
+    this.#pump = this.#pumpSource();
+    if (signal.aborted) {
+      this.#onAbort();
+    }
+  }
+  async nextChunk() {
+    while (this.#frames.length === 0 && !this.#done && !this.#hasError) {
+      await new Promise((resolve) => {
+        this.#dataWaker = resolve;
+      });
+    }
+    if (this.#frames.length > 0) {
+      const chunk = this.#takeQueued();
+      this.#wakeSpace();
+      return chunk;
+    }
+    if (this.#hasError) {
+      this.#hasError = false;
+      throw this.#error;
+    }
+    return void 0;
+  }
+  #takeQueued() {
+    const frames = this.#frames;
+    const total = this.#queued;
+    this.#queued = 0;
+    if (frames.length === 1) {
+      return frames.pop();
+    }
+    const chunk = new Uint8Array(total);
+    let offset = 0;
+    for (const frame of frames) {
+      chunk.set(frame, offset);
+      offset += frame.byteLength;
+    }
+    frames.length = 0;
+    return chunk;
+  }
+  async dispose() {
+    this.#signal.removeEventListener("abort", this.#onAbort);
+    if (!this.#done) {
+      await this.cancel();
+    } else if (this.#cancelPromise) {
+      await this.#cancelPromise;
+    }
+    await this.#pump;
+  }
+  cancel(reason) {
+    if (this.#done) {
+      return Promise.resolve();
+    }
+    if (!this.#cancelPromise) {
+      this.#cancelled = true;
+      this.#done = true;
+      this.#hasError = true;
+      this.#error = reason instanceof Error ? reason : new Error("HTTP response body cancelled.");
+      this.#frames.length = 0;
+      this.#queued = 0;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#cancelPromise = this.#reader.cancel(reason).catch(() => void 0);
+    }
+    return this.#cancelPromise;
+  }
+  async #pumpSource() {
+    try {
+      while (!this.#cancelled) {
+        while (this.#queued >= HTTP_RESPONSE_READ_AHEAD_BYTES && !this.#cancelled) {
+          await new Promise((resolve) => {
+            this.#spaceWaker = resolve;
+          });
+        }
+        if (this.#cancelled) {
+          return;
+        }
+        const { value, done } = await this.#reader.read();
+        if (done) {
+          return;
+        }
+        if (value.byteLength > 0) {
+          this.#frames.push(value);
+          this.#queued += value.byteLength;
+          this.#wakeData();
+          continue;
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+    } catch (error) {
+      if (!this.#cancelled) {
+        this.#hasError = true;
+        this.#error = error;
+      }
+    } finally {
+      this.#done = true;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#reader.releaseLock();
+    }
+  }
+  #wakeData() {
+    const waker = this.#dataWaker;
+    this.#dataWaker = void 0;
+    waker?.();
+  }
+  #wakeSpace() {
+    const waker = this.#spaceWaker;
+    this.#spaceWaker = void 0;
+    waker?.();
   }
 }
 function headersToMultiMap(headers) {

package/dist/node_modules/@github/copilot-sdk/dist/cjs/extension.js

@@ -20,17 +20,17 @@ var extension_exports = {};
 __export(extension_exports, {
   Canvas: () => import_canvas.Canvas,
   CanvasError: () => import_canvas.CanvasError,
-  FactoryResumeError: () => import_factory.FactoryResumeError,
+  WorkflowResumeError: () => import_workflow.WorkflowResumeError,
   createCanvas: () => import_canvas.createCanvas,
-  defineFactory: () => import_factory.defineFactory,
-  isFactoryRunTerminal: () => import_factory.isFactoryRunTerminal,
+  defineWorkflow: () => import_workflow.defineWorkflow,
+  isWorkflowRunTerminal: () => import_workflow.isWorkflowRunTerminal,
   joinSession: () => joinSession
 });
 module.exports = __toCommonJS(extension_exports);
 var import_client = require("./client.js");
 var import_types = require("./types.js");
 var import_canvas = require("./canvas.js");
-var import_factory = require("./factory.js");
+var import_workflow = require("./workflow.js");
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -41,11 +41,13 @@ async function joinSession(config = {}) {
   const client = new import_client.CopilotClient({ _internalConnection: { kind: "parent-process" } });
   const {
     extensionSdkPath: _stripped,
-    factories,
+    skillProvider: _strippedSkillProvider,
+    workflows,
     requestedEnvironmentVariables,
     ...rest
   } = config;
   void _stripped;
+  void _strippedSkillProvider;
   return client.resumeSessionForExtension(
     sessionId,
     {
@@ -53,7 +55,7 @@ async function joinSession(config = {}) {
       onPermissionRequest: config.onPermissionRequest ?? import_types.defaultJoinSessionPermissionHandler,
       suppressResumeEvent: config.suppressResumeEvent ?? true
     },
-    factories,
+    { workflows },
     requestedEnvironmentVariables?.length ? { requestedEnvironmentVariables } : void 0
   );
 }
@@ -61,9 +63,9 @@ async function joinSession(config = {}) {
 0 && (module.exports = {
   Canvas,
   CanvasError,
-  FactoryResumeError,
+  WorkflowResumeError,
   createCanvas,
-  defineFactory,
-  isFactoryRunTerminal,
+  defineWorkflow,
+  isWorkflowRunTerminal,
   joinSession
 });

package/dist/node_modules/@github/copilot-sdk/dist/cjs/ffiRuntimeHost.js

@@ -208,7 +208,7 @@ class FfiRuntimeHost {
       );
       if (!this.connectionId) {
         this.unregisterCallback();
-        this.lib.hostShutdown(this.serverId);
+        await this.shutdownHost();
         this.serverId = 0;
         throw new Error("copilot_runtime_connection_open failed.");
       }
@@ -217,7 +217,7 @@ class FfiRuntimeHost {
     } finally {
       this.starting = false;
       if (this.disposed) {
-        void this.tryFinalizeCleanup();
+        await this.tryFinalizeCleanup();
       }
     }
   }
@@ -256,6 +256,17 @@ class FfiRuntimeHost {
       );
     }
   }
+  shutdownHost() {
+    return new Promise((resolvePromise, rejectPromise) => {
+      this.lib.hostShutdown.async(this.serverId, (error, result) => {
+        if (error) {
+          rejectPromise(error);
+        } else {
+          resolvePromise(result);
+        }
+      });
+    });
+  }
   unregisterCallback() {
     if (this.outboundCallback === void 0) {
       return true;
@@ -328,7 +339,7 @@ class FfiRuntimeHost {
       }
       if (this.serverId) {
         try {
-          if (!this.lib.hostShutdown(this.serverId)) {
+          if (!await this.shutdownHost()) {
             console.error(
               `In-process FFI host shutdown did not recognize server ${this.serverId}.`
             );