@github/copilot-sdk 1.0.14 → 1.0.15-preview.1

package/dist/cjs/workflow.js

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workflow_exports = {};
+__export(workflow_exports, {
+  WORKFLOW_AGENT_OPTION_KEYS: () => WORKFLOW_AGENT_OPTION_KEYS,
+  WorkflowResumeError: () => WorkflowResumeError,
+  defineWorkflow: () => defineWorkflow,
+  getWorkflowDefinition: () => getWorkflowDefinition,
+  isWorkflowRunTerminal: () => isWorkflowRunTerminal
+});
+module.exports = __toCommonJS(workflow_exports);
+const WORKFLOW_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "halted",
+  "paused",
+  "cancelled",
+  "error"
+]);
+function isWorkflowRunTerminal(status) {
+  return WORKFLOW_TERMINAL_STATUSES.has(status);
+}
+const WORKFLOW_AGENT_OPTION_KEYS = [
+  "label",
+  "schema",
+  "model",
+  "reasoningEffort",
+  "contextTier",
+  "agent"
+];
+class WorkflowResumeError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorkflowResumeError";
+  }
+  code;
+}
+const workflowHandles = /* @__PURE__ */ new WeakMap();
+const MAX_WORKFLOW_TIMEOUT_SECONDS = 2147483647e-3;
+const NANO_AIU_PER_AIU = 1e9;
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const nested of Object.values(value)) {
+      deepFreeze(nested);
+    }
+  }
+  return value;
+}
+function validateLimits(meta) {
+  const limits = meta.limits;
+  if (!limits) {
+    return;
+  }
+  for (const field of ["maxConcurrentSubagents", "maxTotalSubagents"]) {
+    const value = limits[field];
+    if (value !== void 0 && (!Number.isInteger(value) || value <= 0)) {
+      throw new Error(`Workflow limit "${field}" must be a positive integer`);
+    }
+  }
+  if (limits.timeoutSeconds !== void 0 && (!Number.isFinite(limits.timeoutSeconds) || limits.timeoutSeconds <= 0)) {
+    throw new Error(
+      'Workflow limit "timeoutSeconds" must be a positive, finite number of seconds'
+    );
+  }
+  if (limits.timeoutSeconds !== void 0 && limits.timeoutSeconds > MAX_WORKFLOW_TIMEOUT_SECONDS) {
+    throw new Error(
+      `Workflow limit "timeoutSeconds" must not exceed ${MAX_WORKFLOW_TIMEOUT_SECONDS} seconds`
+    );
+  }
+  if (limits.maxAiCredits !== void 0) {
+    const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU);
+    if (!Number.isFinite(limits.maxAiCredits) || limits.maxAiCredits <= 0 || !Number.isSafeInteger(maxNanoAiu) || maxNanoAiu < 1) {
+      throw new Error(
+        'Workflow limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
+      );
+    }
+  }
+}
+function validatePhases(meta) {
+  const titles = /* @__PURE__ */ new Set();
+  for (const phase of meta.phases) {
+    if (phase.title.trim().length === 0) {
+      throw new Error("Workflow phase titles must not be empty");
+    }
+    if (titles.has(phase.title)) {
+      throw new Error(`Workflow phase title "${phase.title}" is declared more than once`);
+    }
+    titles.add(phase.title);
+  }
+}
+function defineWorkflow(definition) {
+  const meta = deepFreeze(structuredClone(definition.meta));
+  validateLimits(meta);
+  validatePhases(meta);
+  const stored = {
+    meta,
+    run: definition.run
+  };
+  const handle = Object.freeze({ meta });
+  workflowHandles.set(handle, stored);
+  return handle;
+}
+function getWorkflowDefinition(handle) {
+  const definition = workflowHandles.get(handle);
+  if (!definition) {
+    throw new Error("Invalid workflow handle");
+  }
+  return definition;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKFLOW_AGENT_OPTION_KEYS,
+  WorkflowResumeError,
+  defineWorkflow,
+  getWorkflowDefinition,
+  isWorkflowRunTerminal
+});

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.85";
+export declare const COPILOT_CLI_VERSION = "1.0.89-0";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.85";
+const COPILOT_CLI_VERSION = "1.0.89-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -6,6 +6,7 @@ export declare class CopilotClient {
     private cliProcess;
     private ffiHost;
     private connection;
+    private requestAdapter;
     private messageWriter;
     private connectionClosed;
     private socket;
@@ -41,6 +42,7 @@ export declare class CopilotClient {
     /** Connection-level session filesystem config, set via constructor option. */
     private sessionFsConfig;
     private requestHandler;
+    private extensionLaunchProvider?;
     private builtinPluginDirectories;
     private onGitHubTelemetry?;
     private clientGlobalHandlers;

package/dist/client.js

@@ -23,13 +23,11 @@ import { COPILOT_CLI_VERSION } from "./cliVersion.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
 import { createCopilotRequestAdapter } from "./copilotRequestHandler.js";
 import { getTraceContext } from "./telemetry.js";
+import { toJsonSchema } from "./schema.js";
 import { ToolSet } from "./toolSet.js";
 import { defaultJoinSessionPermissionHandler } from "./types.js";
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
-function isZodSchema(value) {
-  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
-}
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
   try {
@@ -74,13 +72,6 @@ async function waitForChildExit(child, timeoutMs) {
     }
   });
 }
-function toJsonSchema(parameters) {
-  if (!parameters) return void 0;
-  if (isZodSchema(parameters)) {
-    return parameters.toJSONSchema();
-  }
-  return parameters;
-}
 const DEFAULT_PROVIDER_NAME = "default";
 function extractBearerTokenProviders(provider, providers) {
   const callbacks = /* @__PURE__ */ new Map();
@@ -213,6 +204,7 @@ class CopilotClient {
   cliProcess = null;
   ffiHost = null;
   connection = null;
+  requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
   socket = null;
@@ -250,6 +242,7 @@ class CopilotClient {
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
   requestHandler = null;
+  extensionLaunchProvider;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -407,6 +400,7 @@ class CopilotClient {
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
+    this.extensionLaunchProvider = options.extensionLaunchProvider;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -509,14 +503,16 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
-      handlers.llmInference = createCopilotRequestAdapter(this.requestHandler, () => {
+      this.requestAdapter = createCopilotRequestAdapter(this.requestHandler, () => {
         if (!this.connection) {
           return void 0;
         }
         this._rpc ??= createServerRpc(this.connection);
         return this._rpc;
       });
+      handlers.llmInference = this.requestAdapter;
     }
     if (this.onGitHubTelemetry) {
       const onGitHubTelemetry = this.onGitHubTelemetry;
@@ -621,6 +617,9 @@ class CopilotClient {
       }
       await this.connectToServer();
       await this.verifyProtocolVersion();
+      if (this.extensionLaunchProvider) {
+        await this.rpc.registerExtensionLaunchProvider();
+      }
       if (this.builtinPluginDirectories.length > 0) {
         try {
           await this.connection.sendRequest("plugins.builtin.set", {
@@ -709,6 +708,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -864,6 +864,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -1314,11 +1315,14 @@ class CopilotClient {
   async resumeSession(sessionId, config) {
     return this.resumeSessionInternal(sessionId, config);
   }
-  /** @internal */
-  async resumeSessionForExtension(sessionId, config, factories, extensionOptions) {
-    return this.resumeSessionInternal(sessionId, config, factories, extensionOptions);
+  async resumeSessionForExtension(sessionId, config, contributions = {}, extensionOptions) {
+    return this.resumeSessionInternal(sessionId, config, contributions, extensionOptions);
   }
-  async resumeSessionInternal(sessionId, config, factories, extensionOptions) {
+  async resumeSessionInternal(sessionId, config, contributions = {}, extensionOptions) {
+    const { factories, workflows } = Array.isArray(contributions) ? { factories: contributions, workflows: void 0 } : contributions;
+    if (factories !== void 0 && workflows !== void 0) {
+      throw new Error("Session configuration cannot include both factories and workflows");
+    }
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
@@ -1339,6 +1343,7 @@ class CopilotClient {
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
     session.registerFactories(factories);
+    session.registerWorkflows(workflows);
     const {
       wireProvider: bearerWireProvider,
       wireProviders: bearerWireProviders,
@@ -1420,6 +1425,7 @@ class CopilotClient {
         toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
         factories: factories?.map((factory) => factory.meta),
+        workflows: workflows?.map((workflow) => workflow.meta),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
         extensionSdkPath: config.extensionSdkPath,
@@ -2272,6 +2278,7 @@ stderr: ${stderrOutput}` : ""}`
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
+      this.requestAdapter?.cancelPending();
     };
     this.connection.onClose(markDisconnected);
     this.connection.onError(() => {

package/dist/copilotRequestHandler.js

@@ -1,5 +1,6 @@
 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");
@@ -238,7 +239,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 {
@@ -251,6 +254,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");
+      }
     }
   };
 }
@@ -499,30 +509,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/extension.d.ts

@@ -1,7 +1,27 @@
 import type { CopilotSession } from "./session.js";
 import { type PermissionHandler, type ResumeSessionConfig } from "./types.js";
 import type { FactoryHandle } from "./factory.js";
+import type { WorkflowHandle } from "./workflow.js";
 export { Canvas, CanvasError, createCanvas, type CanvasAction, type CanvasDeclaration, type CanvasHostContext, type CanvasJsonSchema, type CanvasOptions, } from "./canvas.js";
+type JoinSessionContributionConfig = {
+    /**
+     * Factory handles to register when the extension joins the session.
+     *
+     * @experimental Part of the experimental Agent Factories surface and may
+     * change or be removed in future SDK or CLI releases.
+     */
+    factories?: FactoryHandle[];
+    workflows?: never;
+} | {
+    factories?: never;
+    /**
+     * Workflow handles to register when the extension joins the session.
+     *
+     * @experimental Part of the experimental Dynamic Workflows surface and may
+     * change or be removed in future SDK or CLI releases.
+     */
+    workflows?: WorkflowHandle[];
+};
 export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest" | "extensionSdkPath"> & {
     onPermissionRequest?: PermissionHandler;
     /**
@@ -33,16 +53,10 @@ export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest"
      * ```
      */
     requestedEnvironmentVariables?: string[];
-    /**
-     * Factory handles to register when the extension joins the session.
-     *
-     * @experimental Part of the experimental Agent Factories surface and may
-     * change or be removed in future SDK or CLI releases.
-     */
-    factories?: FactoryHandle[];
-};
+} & JoinSessionContributionConfig;
 export type { ExtensionInfo, FactoryLimits, FactoryMeta } from "./types.js";
 export { defineFactory, FactoryResumeError, isFactoryRunTerminal, type RunOptions, type ResumeOptions, type FactoryResumeErrorCode, type SessionFactoryApi, type FactoryAgentOptions, type FactoryContext, type FactoryDefinition, type FactoryHandle, type FactoryJsonSchema, type JsonValue, type FactoryPipelineStage, type FactoryStepOptions, type FactoryRunResult, type FactoryRunStatus, type FactoryRunSummary, type FactoryListRunsOptions, type FactoryRunsPage, type FactoryRunDetail, type FactoryProgressPage, type FactoryProgressLine, type FactoryPhaseObservation, type FactoryPhaseStatus, type FactoryAgentSummary, } from "./factory.js";
+export { defineWorkflow, WorkflowResumeError, isWorkflowRunTerminal, type WorkflowRunOptions, type WorkflowResumeOptions, type WorkflowLimitOverrides, type WorkflowResumeErrorCode, type SessionWorkflowApi, type WorkflowAgentOptions, type WorkflowContext, type WorkflowDefinition, type WorkflowHandle, type WorkflowJsonSchema, type WorkflowLimits, type WorkflowMeta, type WorkflowPipelineStage, type WorkflowStepOptions, type WorkflowRunResult, type WorkflowRunStatus, type WorkflowRunSummary, type WorkflowListRunsOptions, type WorkflowRunsPage, type WorkflowRunDetail, type WorkflowProgressPage, type WorkflowProgressLine, type WorkflowPhaseObservation, type WorkflowPhaseStatus, type WorkflowAgentSummary, } from "./workflow.js";
 /**
  * Joins the current foreground session.
  *

package/dist/extension.js

@@ -12,6 +12,11 @@ import {
   FactoryResumeError,
   isFactoryRunTerminal
 } from "./factory.js";
+import {
+  defineWorkflow,
+  WorkflowResumeError,
+  isWorkflowRunTerminal
+} from "./workflow.js";
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -23,10 +28,14 @@ async function joinSession(config = {}) {
   const {
     extensionSdkPath: _stripped,
     factories,
+    workflows,
     requestedEnvironmentVariables,
     ...rest
   } = config;
   void _stripped;
+  if (factories !== void 0 && workflows !== void 0) {
+    throw new Error("joinSession cannot register both factories and workflows");
+  }
   return client.resumeSessionForExtension(
     sessionId,
     {
@@ -34,7 +43,7 @@ async function joinSession(config = {}) {
       onPermissionRequest: config.onPermissionRequest ?? defaultJoinSessionPermissionHandler,
       suppressResumeEvent: config.suppressResumeEvent ?? true
     },
-    factories,
+    { factories, workflows },
     requestedEnvironmentVariables?.length ? { requestedEnvironmentVariables } : void 0
   );
 }
@@ -42,8 +51,11 @@ export {
   Canvas,
   CanvasError,
   FactoryResumeError,
+  WorkflowResumeError,
   createCanvas,
   defineFactory,
+  defineWorkflow,
   isFactoryRunTerminal,
+  isWorkflowRunTerminal,
   joinSession
 };