@github/copilot-sdk 1.0.14-preview.0 → 1.0.14-unstable.35049111350.g7f86a90

package/README.md

@@ -21,6 +21,10 @@ release's `SHA256SUMS.txt`.
 
 `npm run pack:release` builds the main package and all platform packages. Set
 `COPILOT_CLI_DOWNLOAD_BASE_URL` to use a release mirror while packaging.
+Release workflows instead set `COPILOT_SDK_RUNTIME_PACKAGE_DIR` to a directory
+containing validated runtime npm package roots named for all eight platforms.
+This keeps `COPILOT_CLI_USE_NPM_PACKAGE` false and embeds those runtime files in
+the self-contained SDK platform packages.
 
 ## Installation
 

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.84-5";
+const COPILOT_CLI_VERSION = "1.0.84-9.unstable.r35045926061.g4848e94";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/factory.js

@@ -28,6 +28,7 @@ module.exports = __toCommonJS(factory_exports);
 const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "halted",
+  "paused",
   "cancelled",
   "error"
 ]);

package/dist/cjs/generated/rpc.js

@@ -760,15 +760,7 @@ function createInternalServerRpc(connection) {
        */
       getBoardEntryCount: async (params) => connection.sendRequest("sessions.getBoardEntryCount", params),
       /**
-       * Registers extension-provided tools on the given session, gated by an optional `enabled` callback. Returns an opaque unsubscribe function the caller must invoke to deregister the tools when the extension is torn down. Marked internal because `loader`, `enabled`, and the returned `unsubscribe` are in-process handles that cannot cross the JSON-RPC boundary. Disappears once extension discovery / launch / tool registration are owned by the runtime: SDK consumers will pass pure config (search paths, disabled ids) via `SessionOptions` and the runtime will resolve, launch, register, and tear down extensions itself.
-       *
-       * @param params Params to attach an extension loader's tools to a session.
-       *
-       * @returns Handle for releasing the extension tool registration.
-       */
-      registerExtensionToolsOnSession: async (params) => connection.sendRequest("sessions.registerExtensionToolsOnSession", params),
-      /**
-       * Attaches (or detaches) an in-process ExtensionController delegate for the given session, used by shared-API surfaces that need to query or modify the session's extension state. Pass `controller: undefined` to detach. Marked internal because the controller is an in-process object that cannot cross the JSON-RPC boundary. Disappears alongside `registerExtensionToolsOnSession`: once the runtime owns extension management, the public surface exposes list/enable/disable/reload as dedicated RPCs served by the runtime.
+       * Attaches (or detaches) an in-process ExtensionController delegate for the given session in a local host adapter. Pass `controller: undefined` to detach. Internal because the controller cannot cross the JSON-RPC boundary; the runtime manages its own session extension service.
        *
        * @param params Params to attach or detach an in-process ExtensionController delegate.
        */
@@ -877,11 +869,11 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     debug: {
       /**
-       * Collects a redacted session debug log bundle into a local archive or staging directory. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.
+       * Collects a session debug log bundle into a local archive or staging directory. Logs are redacted by default; redaction can be configured per caller-provided diagnostic entry. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.
        *
-       * @param params Options for collecting a redacted session debug bundle.
+       * @param params Options for collecting a session debug bundle with configurable redaction.
        *
-       * @returns Result of collecting a redacted debug bundle.
+       * @returns Result of collecting a session debug bundle.
        */
       collectLogs: async (params) => connection.sendRequest("session.debug.collectLogs", { sessionId, ...params })
     },
@@ -1191,6 +1183,32 @@ function createSessionRpc(connection, sessionId) {
        * @param params Relative path and UTF-8 content for the workspace file to create or overwrite.
        */
       createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { sessionId, ...params }),
+      /**
+       * Returns metadata for a file or directory in the session workspace files directory.
+       *
+       * @param params Relative path of the workspace file or directory to inspect.
+       *
+       * @returns Filesystem metadata for a path in the session workspace files directory.
+       */
+      statFile: async (params) => connection.sendRequest("session.workspaces.statFile", { sessionId, ...params }),
+      /**
+       * Creates a directory in the session workspace files directory.
+       *
+       * @param params Directory to create within the session workspace files directory.
+       */
+      createDirectory: async (params) => connection.sendRequest("session.workspaces.createDirectory", { sessionId, ...params }),
+      /**
+       * Removes a file or directory from the session workspace files directory.
+       *
+       * @param params File or directory to remove from the session workspace files directory.
+       */
+      removePath: async (params) => connection.sendRequest("session.workspaces.removePath", { sessionId, ...params }),
+      /**
+       * Renames a file or directory within the session workspace files directory.
+       *
+       * @param params Source and destination paths for a rename within the session workspace files directory.
+       */
+      renamePath: async (params) => connection.sendRequest("session.workspaces.renamePath", { sessionId, ...params }),
       /**
        * Lists workspace checkpoints in chronological order.
        *

package/dist/cjs/session.js

@@ -41,10 +41,14 @@ const factoryExecutionStore = new import_node_async_hooks.AsyncLocalStorage();
 function throwIfFactoryExecutionIsActive() {
   if (factoryExecutionStore.getStore()?.active) {
     throw new Error(
-      "factory.run and factory.resume are not allowed while a factory body is running on this call path."
+      "factory.run, factory.resume, and factory.pause are not allowed while a factory body is running on this call path."
     );
   }
 }
+function runInFactoryHelperScope(helperScope, callback) {
+  const current = factoryExecutionStore.getStore();
+  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
+}
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -88,7 +92,7 @@ async function runFactoryParallel(thunks) {
   }
   return Promise.all(
     thunks.map(
-      (thunk) => Promise.resolve().then(() => thunk()).catch((error) => {
+      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
         if (isFactoryFatalError(error)) {
           throw error;
         }
@@ -107,7 +111,10 @@ async function runFactoryPipeline(items, ...stages) {
       let previous = item;
       for (const stage of stages) {
         try {
-          previous = await stage(previous, item, index);
+          previous = await runInFactoryHelperScope(
+            "pipeline",
+            () => stage(previous, item, index)
+          );
         } catch (error) {
           if (isFactoryFatalError(error)) {
             throw error;
@@ -264,6 +271,7 @@ class CopilotSession {
   hooks;
   transformCallbacks;
   _rpc = null;
+  _internalRpc = null;
   traceContextProvider;
   managedSettingsEnabled;
   _capabilities = {};
@@ -330,6 +338,10 @@ class CopilotSession {
     }),
     getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
     getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
+    pause: async (runId) => {
+      throwIfFactoryExecutionIsActive();
+      return this.rpc.factory.pause({ runId });
+    },
     cancel: async (runId) => this.rpc.factory.cancel({ runId })
   };
   /**
@@ -428,6 +440,13 @@ class CopilotSession {
     }
     return this._rpc;
   }
+  /** @internal */
+  get internalRpc() {
+    if (!this._internalRpc) {
+      this._internalRpc = (0, import_rpc.createInternalSessionRpc)(this.connection, this.sessionId);
+    }
+    return this._internalRpc;
+  }
   /**
    * Path to the session workspace directory when infinite sessions are enabled.
    * Contains checkpoints/, plan.md, and files/ subdirectories.
@@ -1110,6 +1129,36 @@ class CopilotSession {
               );
               return result2;
             },
+            pause: async (key) => {
+              if (typeof key !== "string" || key.length === 0) {
+                throw new Error("Factory pause checkpoint key must not be empty");
+              }
+              const helperScope = factoryExecutionStore.getStore()?.helperScope;
+              if (helperScope !== void 0) {
+                throw new Error(
+                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
+                );
+              }
+              await progress.flush();
+              const response = await awaitFactoryOperation(
+                () => self.internalRpc.factory.pauseAtCheckpoint({
+                  runId: params.runId,
+                  executionToken: params.executionToken,
+                  key
+                }),
+                controller.signal
+              );
+              switch (response.action) {
+                case "continue":
+                  return;
+                case "pause":
+                  await awaitFactoryOperation(
+                    () => new Promise(() => {
+                    }),
+                    controller.signal
+                  );
+              }
+            },
             parallel: runFactoryParallel,
             pipeline: runFactoryPipeline,
             factory: async () => {
@@ -1145,11 +1194,9 @@ class CopilotSession {
       },
       async abort(params) {
         const controllersForRun = self.factoryAbortControllers.get(params.runId);
-        if (controllersForRun !== void 0) {
-          const reason = new DOMException("Factory run was aborted", "AbortError");
-          for (const controller of controllersForRun.values()) {
-            controller.abort(reason);
-          }
+        const controller = controllersForRun?.get(params.executionToken);
+        if (controller !== void 0) {
+          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
         }
         return {};
       }

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.84-5";
+export declare const COPILOT_CLI_VERSION = "1.0.84-9.unstable.r35045926061.g4848e94";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.84-5";
+const COPILOT_CLI_VERSION = "1.0.84-9.unstable.r35045926061.g4848e94";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/factory.d.ts

@@ -1,7 +1,7 @@
 import type { FactoryGetRunProgressRequest, FactoryListRunsRequest, FactoryListRunsResult, FactoryProgressPage, FactoryRunDetail, FactoryRunResult, FactoryRunStatus, FactoryRunSummary } from "./generated/rpc.js";
 import type { ContextTier } from "./generated/session-events.js";
 import type { CopilotSession } from "./session.js";
-import type { FactoryLimits, FactoryMeta } from "./types.js";
+import type { FactoryMeta } from "./types.js";
 export type { FactoryRunResult };
 export type { FactoryAgentSummary, FactoryPhaseStatus, FactoryPhaseObservation, FactoryProgressLine, FactoryProgressPage, FactoryRunDetail, FactoryRunStatus, FactoryRunSummary, } from "./generated/rpc.js";
 /**
@@ -81,6 +81,21 @@ export interface FactoryStepOptions {
     /** Skip the journal and always invoke the producer. */
     volatile?: boolean;
 }
+/**
+ * Per-invocation factory resource ceiling overrides.
+ *
+ * An omitted field preserves the existing/default ceiling, a number replaces
+ * it, and `null` explicitly makes that dimension unlimited.
+ *
+ * @experimental Part of the experimental Agent Factories surface and may
+ * change or be removed in future SDK or CLI releases.
+ */
+export interface FactoryLimitOverrides {
+    maxConcurrentSubagents?: number | null;
+    maxTotalSubagents?: number | null;
+    maxAiCredits?: number | null;
+    timeoutSeconds?: number | null;
+}
 /**
  * One stage in a per-item factory pipeline.
  *
@@ -101,6 +116,13 @@ export interface FactoryContext<TArgs extends JsonValue = JsonValue> {
     agent(prompt: string, options?: FactoryAgentOptions): Promise<unknown>;
     /** Memoize an arbitrary producer under a stable author-supplied key. */
     step(key: string, producer: () => Promise<JsonValue> | JsonValue, options?: FactoryStepOptions): Promise<JsonValue>;
+    /**
+     * Pause this run at a durable, one-shot checkpoint.
+     *
+     * The first attempt to reach a key pauses and aborts cooperatively. A
+     * resumed attempt returns from the same key and continues.
+     */
+    pause(key: string): Promise<void>;
     /**
      * Run thunks concurrently and await all of them.
      *
@@ -129,7 +151,7 @@ export interface FactoryContext<TArgs extends JsonValue = JsonValue> {
     args: TArgs;
     /**
      * The session instance returned by `joinSession`. It refuses calls that
-     * start or resume a factory run.
+     * start, resume, or pause a factory run.
      */
     session: CopilotSession;
     /** Cooperative cancellation signal for the current factory run. */
@@ -178,7 +200,7 @@ export interface RunOptions<TArgs extends JsonValue = JsonValue> {
     /** Input surfaced as `context.args`. */
     args?: TArgs;
     /** Optional per-invocation resource ceiling overrides. */
-    limits?: FactoryLimits;
+    limits?: FactoryLimitOverrides;
     /** Whether to notify the originating session when the factory completes. */
     notifyOnComplete?: boolean;
     /** Whether to emit factory phase names to the session transcript. */
@@ -198,7 +220,7 @@ export interface RunOptions<TArgs extends JsonValue = JsonValue> {
  */
 export interface ResumeOptions {
     /** Optional per-invocation resource ceiling overrides. */
-    limits?: FactoryLimits;
+    limits?: FactoryLimitOverrides;
     /** Whether to notify the originating session when the factory completes. */
     notifyOnComplete?: boolean;
     /** Whether to emit factory phase names to the session transcript. */
@@ -222,13 +244,14 @@ export interface SessionFactoryApi {
      * Run a registered factory and resolve with its run envelope.
      *
      * The envelope is returned for every outcome, including `error`, `halted`,
-     * and `cancelled` — inspect `status` and read `result` only when the run
-     * completed. SDK-initiated runs do not request permission, so they have no
-     * declined outcome. The model's `run_factory` tool requests permission
-     * before a durable row exists; declining it creates no run row. Failures
-     * that occur before a run exists (such as an unknown factory or attempting
-     * to start a run while the session is at its active top-level run limit)
-     * still reject.
+     * `paused`, and `cancelled` — inspect `status` and read `result` only when
+     * the run completed. `paused` settles the current attempt, but the same
+     * durable run can later resume under its existing run ID. SDK-initiated
+     * runs do not request permission, so they have no declined outcome. The
+     * model's `run_factory` tool requests permission before a durable row
+     * exists; declining it creates no run row. Failures that occur before a run
+     * exists (such as an unknown factory or attempting to start a run while the
+     * session is at its active top-level run limit) still reject.
      */
     run(name: string, options?: RunOptions): Promise<FactoryRunResult>;
     run<TArgs extends JsonValue>(factory: FactoryHandle<TArgs, JsonValue | void>, options?: RunOptions<TArgs>): Promise<FactoryRunResult>;
@@ -243,12 +266,13 @@ export interface SessionFactoryApi {
     /** Read the latest durable envelope for a factory run. */
     getRun(runId: string): Promise<FactoryRunResult>;
     /**
-     * Wait for a run to settle and resolve with its terminal envelope.
+     * Wait for the current attempt to settle and resolve with its envelope.
      *
-     * Resolves as soon as the run reaches `completed`, `error`, `halted`, or
-     * `cancelled`, and resolves immediately when it has already settled. A
-     * terminal envelope is final, so the resolved value never changes
-     * afterwards.
+     * Resolves as soon as the run reaches `completed`, `error`, `halted`,
+     * `paused`, or `cancelled`, and resolves immediately when the current
+     * attempt has already settled. A `paused` envelope is an attempt-level
+     * snapshot: resuming the same durable run can later change the envelope
+     * returned by {@link SessionFactoryApi.getRun}.
      *
      * This watches the run's `factory.run_updated` invalidation events and
      * periodically re-reads the durable envelope so a missed event cannot
@@ -279,6 +303,8 @@ export interface SessionFactoryApi {
     getRunDetail(runId: string): Promise<FactoryRunDetail>;
     /** Page durable progress forward, backward, or from the latest tail. */
     getRunProgress(runId: string, options?: Omit<FactoryGetRunProgressRequest, "runId">): Promise<FactoryProgressPage>;
+    /** Pause a running factory attempt and return its `paused` envelope. */
+    pause(runId: string): Promise<FactoryRunResult>;
     /** Cancel a factory run and return its terminal envelope. */
     cancel(runId: string): Promise<FactoryRunResult>;
 }

package/dist/factory.js

@@ -1,6 +1,7 @@
 const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "halted",
+  "paused",
   "cancelled",
   "error"
 ]);