@github/copilot-sdk 1.0.10-preview.0 → 1.0.11-preview.1

package/dist/cjs/client.js

@@ -1111,6 +1111,7 @@ class CopilotClient {
         models: config.models,
         enableSessionTelemetry: config.enableSessionTelemetry,
         enableCitations: config.enableCitations,
+        enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
         modelCapabilities: config.modelCapabilities,
         largeOutput: toWireLargeOutput(config.largeOutput),
@@ -1298,6 +1299,7 @@ class CopilotClient {
         enableSessionTelemetry: config.enableSessionTelemetry,
         excludedBuiltinAgents: config.excludedBuiltinAgents,
         enableCitations: config.enableCitations,
+        enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
         tools: config.tools?.map((tool) => ({
           name: tool.name,

package/dist/cjs/factory.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var factory_exports = {};
 __export(factory_exports, {
+  FACTORY_AGENT_OPTION_KEYS: () => FACTORY_AGENT_OPTION_KEYS,
   FactoryResumeError: () => FactoryResumeError,
   defineFactory: () => defineFactory,
   getFactoryDefinition: () => getFactoryDefinition,
@@ -33,6 +34,14 @@ const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
 function isFactoryRunTerminal(status) {
   return FACTORY_TERMINAL_STATUSES.has(status);
 }
+const FACTORY_AGENT_OPTION_KEYS = [
+  "label",
+  "schema",
+  "model",
+  "reasoningEffort",
+  "contextTier",
+  "agent"
+];
 class FactoryResumeError extends Error {
   constructor(code, message) {
     super(message);
@@ -116,6 +125,7 @@ function getFactoryDefinition(handle) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FACTORY_AGENT_OPTION_KEYS,
   FactoryResumeError,
   defineFactory,
   getFactoryDefinition,

package/dist/cjs/generated/rpc.js

@@ -872,9 +872,11 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Lists durable factory runs for this session in creation order.
        *
-       * @returns Factory runs in durable creation order.
+       * @param params Parameters for paging factory runs.
+       *
+       * @returns A page of factory runs in durable creation order.
        */
-      listRuns: async () => connection.sendRequest("session.factory.listRuns", { sessionId }),
+      listRuns: async (params) => connection.sendRequest("session.factory.listRuns", { sessionId, ...params }),
       /**
        * Gets durable and live observability detail for one factory run.
        *

package/dist/cjs/session.js

@@ -21,13 +21,28 @@ __export(session_exports, {
   CopilotSession: () => CopilotSession
 });
 module.exports = __toCommonJS(session_exports);
+var import_node_async_hooks = require("node:async_hooks");
 var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_canvas = require("./canvas.js");
 var import_telemetry = require("./telemetry.js");
 var import_factory = require("./factory.js");
 function isFactoryResumeErrorCode(value) {
-  return value === "not_found" || value === "non_resumable" || value === "already_active" || value === "reapproval_declined" || value === "no_approval_provider";
+  return value === "not_found" || value === "non_resumable" || value === "already_active" || value === "factory_already_running" || value === "factory_limits_invalid" || value === "factory_session_disposed" || value === "factory_storage_unavailable" || value === "factory_storage_corrupt";
+}
+function copyDefinedFactoryAgentOption(source, target, key) {
+  const value = source[key];
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+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."
+    );
+  }
 }
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
@@ -148,7 +163,10 @@ class FactoryProgressBuffer {
     const lines = this.pending.splice(0);
     await this.flushTail;
     if (this.flushFailed) {
-      throw this.flushError;
+      console.warn(
+        "Ignoring a background factory progress flush failure after the factory body settled",
+        this.flushError
+      );
     }
     if (lines.length > 0) {
       try {
@@ -179,9 +197,6 @@ class FactoryProgressBuffer {
     }
   }
 }
-function toPublicFactoryRunResult(envelope) {
-  return envelope;
-}
 async function awaitFactoryOperation(operation, signal) {
   let rejectAbort;
   const abortPromise = new Promise((_resolve, reject) => {
@@ -261,6 +276,7 @@ class CopilotSession {
    */
   factory = {
     run: (async (nameOrHandle, options) => {
+      throwIfFactoryExecutionIsActive();
       const name = typeof nameOrHandle === "string" ? nameOrHandle : (0, import_factory.getFactoryDefinition)(nameOrHandle).meta.name;
       if (options?.resumeFromRunId !== void 0) {
         return this.factory.resume(options.resumeFromRunId, {
@@ -277,6 +293,7 @@ class CopilotSession {
       return this.settleFactoryRun(envelope);
     }),
     resume: (async (runId, options) => {
+      throwIfFactoryExecutionIsActive();
       let response;
       try {
         response = await this.rpc.factory.resume({
@@ -294,12 +311,12 @@ class CopilotSession {
       }
       return this.settleFactoryRun(response.run);
     }),
-    getRun: async (runId) => toPublicFactoryRunResult(await this.rpc.factory.getRun({ runId })),
+    getRun: async (runId) => this.rpc.factory.getRun({ runId }),
     waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
-    listRuns: async () => (await this.rpc.factory.listRuns()).runs,
+    listRuns: async () => (await this.rpc.factory.listRuns({})).runs,
     getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
     getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
-    cancel: async (runId) => toPublicFactoryRunResult(await this.rpc.factory.cancel({ runId }))
+    cancel: async (runId) => this.rpc.factory.cancel({ runId })
   };
   /**
    * Resolve a start/resume envelope into the terminal envelope callers expect.
@@ -310,7 +327,7 @@ class CopilotSession {
    */
   settleFactoryRun(envelope) {
     if ((0, import_factory.isFactoryRunTerminal)(envelope.status)) {
-      return Promise.resolve(toPublicFactoryRunResult(envelope));
+      return Promise.resolve(envelope);
     }
     return this.waitForFactoryRun(envelope.runId);
   }
@@ -364,7 +381,7 @@ class CopilotSession {
             rereadRequested = false;
             const envelope = await this.rpc.factory.getRun({ runId });
             if ((0, import_factory.isFactoryRunTerminal)(envelope.status)) {
-              finish(() => resolve(toPublicFactoryRunResult(envelope)));
+              finish(() => resolve(envelope));
               return;
             }
           } while (rereadRequested && !settled);
@@ -964,16 +981,16 @@ class CopilotSession {
             },
             agent: async (prompt, options = {}) => {
               await progress.flush();
+              const opts = {};
+              for (const key of import_factory.FACTORY_AGENT_OPTION_KEYS) {
+                copyDefinedFactoryAgentOption(options, opts, key);
+              }
               const response = await awaitFactoryOperation(
                 () => self.rpc.factory.agent({
                   factoryRunId: params.runId,
                   executionToken: params.executionToken,
                   prompt,
-                  opts: {
-                    label: options.label,
-                    schema: options.schema,
-                    model: options.model
-                  }
+                  opts
                 }),
                 controller.signal
               );
@@ -1021,7 +1038,14 @@ class CopilotSession {
               throw new Error("nested factories are not supported");
             }
           };
-          const result = await definition.run(context);
+          const execution = { active: true };
+          const result = await factoryExecutionStore.run(execution, async () => {
+            try {
+              return await definition.run(context);
+            } finally {
+              execution.active = false;
+            }
+          });
           if (result === void 0) {
             return {};
           }

package/dist/client.js

@@ -1088,6 +1088,7 @@ class CopilotClient {
         models: config.models,
         enableSessionTelemetry: config.enableSessionTelemetry,
         enableCitations: config.enableCitations,
+        enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
         modelCapabilities: config.modelCapabilities,
         largeOutput: toWireLargeOutput(config.largeOutput),
@@ -1275,6 +1276,7 @@ class CopilotClient {
         enableSessionTelemetry: config.enableSessionTelemetry,
         excludedBuiltinAgents: config.excludedBuiltinAgents,
         enableCitations: config.enableCitations,
+        enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
         tools: config.tools?.map((tool) => ({
           name: tool.name,

package/dist/factory.d.ts

@@ -1,30 +1,8 @@
-import type { FactoryGetRunProgressRequest, FactoryProgressPage, FactoryRunDetail, FactoryRunResult as WireFactoryRunResult, FactoryRunStatus, FactoryRunSummary } from "./generated/rpc.js";
+import type { FactoryGetRunProgressRequest, 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";
-/**
- * The envelope describing a factory run: its identity, status, and — once it
- * has completed — its result. `getRun` returns this for an in-flight run too,
- * so `status` may be `pending` or `running` and the outcome fields absent.
- *
- * `result` is re-typed here rather than taken from the generated wire type. The
- * runtime returns any JSON value — including `null`, a string, a number, or an
- * array — but the schema models the field as an opaque node, which the
- * generator renders as an object. Narrowing the correction to this surface
- * keeps the `x-opaque-json` handling unchanged for every other consumer.
- *
- * This override is temporary. Once the schema distinguishes an opaque JSON
- * value from an opaque in-process value and that ships in a CLI release,
- * regenerating produces the right type directly, and this declaration, the
- * `toPublicFactoryRunResult` boundary helper, and the casts around it should
- * all be deleted. Tracked by github/copilot-agent-runtime#14122.
- *
- * @experimental Part of the experimental Agent Factories surface and may
- * change or be removed in future SDK or CLI releases.
- */
-export type FactoryRunResult = Omit<WireFactoryRunResult, "result"> & {
-    /** Completed factory result. */
-    result?: JsonValue;
-};
+export type { FactoryRunResult };
 export type { FactoryAgentSummary, FactoryPhaseStatus, FactoryPhaseObservation, FactoryProgressLine, FactoryProgressPage, FactoryRunDetail, FactoryRunStatus, FactoryRunSummary, } from "./generated/rpc.js";
 /**
  * Whether a factory run status is terminal.
@@ -70,7 +48,11 @@ export interface FactoryAgentOptions {
     label?: string;
     schema?: FactoryJsonSchema;
     model?: string;
+    reasoningEffort?: string;
+    contextTier?: ContextTier;
+    agent?: string;
 }
+export declare const FACTORY_AGENT_OPTION_KEYS: readonly ["label", "schema", "model", "reasoningEffort", "contextTier", "agent"];
 /**
  * Options for a durable factory step.
  *
@@ -127,7 +109,10 @@ export interface FactoryContext<TArgs extends JsonValue = JsonValue> {
     factory(name: string, args?: JsonValue): Promise<JsonValue | void>;
     /** Caller-supplied input, forwarded verbatim. */
     args: TArgs;
-    /** The same full session instance returned by `joinSession`. */
+    /**
+     * The session instance returned by `joinSession`. It refuses calls that
+     * start or resume a factory run.
+     */
     session: CopilotSession;
     /** Cooperative cancellation signal for the current factory run. */
     signal: AbortSignal;
@@ -199,7 +184,7 @@ export interface ResumeOptions {
  * @experimental Part of the experimental Agent Factories surface and may
  * change or be removed in future SDK or CLI releases.
  */
-export type FactoryResumeErrorCode = "not_found" | "non_resumable" | "already_active" | "reapproval_declined" | "no_approval_provider";
+export type FactoryResumeErrorCode = "not_found" | "non_resumable" | "already_active" | "factory_already_running" | "factory_limits_invalid" | "factory_session_disposed" | "factory_storage_unavailable" | "factory_storage_corrupt";
 /**
  * Friendly factory API exposed on a session.
  *
@@ -212,18 +197,21 @@ export interface SessionFactoryApi {
      *
      * The envelope is returned for every outcome, including `error`, `halted`,
      * and `cancelled` — inspect `status` and read `result` only when the run
-     * completed. A declined fresh run resolves with a terminal `cancelled`
-     * envelope. Failures that occur before a run exists (such as an unknown
-     * factory or an already-active session) still reject.
+     * 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.
      */
     run(name: string, options?: RunOptions): Promise<FactoryRunResult>;
     run<TArgs extends JsonValue>(factory: FactoryHandle<TArgs, JsonValue | void>, options?: RunOptions<TArgs>): Promise<FactoryRunResult>;
     /**
      * Resume a run from its persisted factory name, arguments, journal, and accounting.
      *
-     * Resolves with the run envelope like {@link SessionFactoryApi.run}. A
-     * pre-execution failure, including declined reapproval, rejects with
-     * {@link FactoryResumeError}.
+     * Resolves with the run envelope like {@link SessionFactoryApi.run}.
+     * SDK-initiated resumes do not request permission. A pre-execution failure
+     * with a documented resume code rejects with {@link FactoryResumeError}.
      */
     resume(runId: string, options?: ResumeOptions): Promise<FactoryRunResult>;
     /** Read the latest durable envelope for a factory run. */
@@ -245,7 +233,9 @@ export interface SessionFactoryApi {
     waitForRun(runId: string, options?: {
         signal?: AbortSignal;
     }): Promise<FactoryRunResult>;
-    /** List this session's durable factory runs in creation order. */
+    /**
+     * List the newest default page of this session's durable factory runs.
+     */
     listRuns(): Promise<FactoryRunSummary[]>;
     /** Read durable phases, direct agents, and the latest progress tail for a run. */
     getRunDetail(runId: string): Promise<FactoryRunDetail>;

package/dist/factory.js

@@ -7,6 +7,14 @@ const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
 function isFactoryRunTerminal(status) {
   return FACTORY_TERMINAL_STATUSES.has(status);
 }
+const FACTORY_AGENT_OPTION_KEYS = [
+  "label",
+  "schema",
+  "model",
+  "reasoningEffort",
+  "contextTier",
+  "agent"
+];
 class FactoryResumeError extends Error {
   constructor(code, message) {
     super(message);
@@ -89,6 +97,7 @@ function getFactoryDefinition(handle) {
   return definition;
 }
 export {
+  FACTORY_AGENT_OPTION_KEYS,
   FactoryResumeError,
   defineFactory,
   getFactoryDefinition,