@github/copilot-sdk 1.0.7 → 1.0.8-preview.0

package/dist/cjs/generated/rpc.js

@@ -762,6 +762,68 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    factory: {
+      /**
+       * Runs a registered factory by name at the top level.
+       *
+       * @param params Parameters for invoking a registered factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
+      /**
+       * Gets the current or settled envelope for a factory run.
+       *
+       * @param params Parameters for retrieving a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
+      /**
+       * Requests cancellation of a factory run and returns its run envelope.
+       *
+       * @param params Parameters for cancelling a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Records a batch of ordered factory progress lines.
+       *
+       * @param params Parameters for recording factory progress.
+       *
+       * @returns Acknowledgement that a factory request was accepted.
+       */
+      log: async (params) => connection.sendRequest("session.factory.log", { sessionId, ...params }),
+      /**
+       * Runs one factory-scoped subagent and returns its result.
+       *
+       * @param params Parameters for one factory-scoped subagent call.
+       *
+       * @returns Result of one factory-scoped subagent call.
+       */
+      agent: async (params) => connection.sendRequest("session.factory.agent", { sessionId, ...params }),
+      /** @experimental */
+      journal: {
+        /**
+         * Reads a memoized factory journal entry.
+         *
+         * @param params Parameters for reading a factory journal entry.
+         *
+         * @returns Result of reading a factory journal entry.
+         */
+        get: async (params) => connection.sendRequest("session.factory.journal.get", { sessionId, ...params }),
+        /**
+         * Stores a memoized factory journal entry.
+         *
+         * @param params Parameters for storing a factory journal entry.
+         *
+         * @returns Acknowledgement that a factory request was accepted.
+         */
+        put: async (params) => connection.sendRequest("session.factory.journal.put", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     model: {
       /**
        * Gets the currently selected model for the session.
@@ -1794,11 +1856,11 @@ function createSessionRpc(connection, sessionId) {
        */
       getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { sessionId, ...params }),
       /**
-       * Records a working-directory/git context change and emits a `session.context_changed` event.
+       * Records a working-directory/git context change and emits a `session.context_changed` event. For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event): a local session's working directory is authoritative and is moved via `metadata.setWorkingDirectory` (or an SDK `session.resume` that supplies a `workingDirectory`), not by this method.
        *
        * @param params Updated working-directory/git context to record on the session.
        *
-       * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode).
+       * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.
        */
       recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { sessionId, ...params }),
       /**
@@ -2068,6 +2130,16 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
     return handler.getToken(params);
   });
+  connection.onRequest("factory.execute", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.execute(params);
+  });
+  connection.onRequest("factory.abort", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.abort(params);
+  });
   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}`);

package/dist/generated/rpc.d.ts

@@ -484,6 +484,79 @@ export type ExternalToolTextResultForLlmContentResourceLinkIconTheme =
  */
 /** @experimental */
 export type ExternalToolTextResultForLlmContentResourceDetails = EmbeddedTextResourceContents | EmbeddedBlobResourceContents;
+/**
+ * Kind of factory progress line.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryLogLineKind".
+ */
+/** @experimental */
+export type FactoryLogLineKind = 
+/** A narrator log line. */
+"log"
+/** A named factory phase marker. */
+ | "phase";
+/**
+ * Machine-readable factory run failure.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunFailure".
+ */
+/** @experimental */
+export type FactoryRunFailure = {
+    kind: FactoryRunFailureKind;
+    /**
+     * Approved effective ceiling that was reached.
+     */
+    value: number;
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    type: "factory_limit_reached";
+} | {
+    /**
+     * Factory run identifier whose changed limits were declined.
+     */
+    runId: string;
+    /**
+     * Human-readable reason the resume did not proceed.
+     */
+    reason: string;
+    type: "factory_resume_declined";
+};
+/**
+ * Cumulative resource ceiling that stopped a factory run.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunFailureKind".
+ */
+/** @experimental */
+export type FactoryRunFailureKind = 
+/** The run admitted the approved maximum total number of subagents. */
+"maxTotalSubagents"
+/** The run reached the approved timeout deadline. */
+ | "timeout";
+/**
+ * Current or terminal state of a factory run.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunStatus".
+ */
+/** @experimental */
+export type FactoryRunStatus = 
+/** The run was minted and is awaiting approval. */
+"pending"
+/** The run is executing. */
+ | "running"
+/** The run completed successfully. */
+ | "completed"
+/** The run was interrupted while resource budget remained. */
+ | "halted"
+/** The run was cancelled before completion. */
+ | "cancelled"
+/** The factory body failed or reached a cumulative resource ceiling. */
+ | "error";
 /**
  * Content filtering mode to apply to all tools, or a map of tool name to content filtering mode.
  *
@@ -4570,6 +4643,340 @@ export interface ExternalToolTextResultForLlmContentResource {
     type: "resource";
     resource: ExternalToolTextResultForLlmContentResourceDetails;
 }
+/**
+ * Parameters for cooperatively aborting a factory body.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryAbortRequest".
+ */
+/** @experimental */
+export interface FactoryAbortRequest {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+}
+/**
+ * Acknowledgement that a factory request was accepted.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryAckResult".
+ */
+/** @experimental */
+export interface FactoryAckResult {
+}
+/**
+ * Options for one factory-scoped subagent call.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryAgentOptions".
+ */
+/** @experimental */
+export interface FactoryAgentOptions {
+    /**
+     * Optional label distinguishing otherwise identical memoized agent calls.
+     */
+    label?: string;
+    /**
+     * Optional JSON Schema for structured agent output.
+     */
+    schema?: {
+        [k: string]: unknown | undefined;
+    };
+    /**
+     * Optional model identifier for the subagent.
+     */
+    model?: string;
+}
+/**
+ * Parameters for one factory-scoped subagent call.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryAgentRequest".
+ */
+/** @experimental */
+export interface FactoryAgentRequest {
+    /**
+     * Factory run identifier that owns the subagent.
+     */
+    factoryRunId: string;
+    /**
+     * Prompt to send to the subagent.
+     */
+    prompt: string;
+    opts: FactoryAgentOptions;
+}
+/**
+ * Result of one factory-scoped subagent call.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryAgentResult".
+ */
+/** @experimental */
+export interface FactoryAgentResult {
+    /**
+     * Agent result, omitted when the agent produced no result.
+     */
+    result?: {
+        [k: string]: unknown | undefined;
+    };
+}
+/**
+ * Parameters for cancelling a factory run.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryCancelRequest".
+ */
+/** @experimental */
+export interface FactoryCancelRequest {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+}
+/**
+ * Parameters sent to the owning extension to execute a factory closure.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryExecuteRequest".
+ */
+/** @experimental */
+export interface FactoryExecuteRequest {
+    /**
+     * Target session identifier
+     */
+    sessionId: string;
+    /**
+     * Registered factory name.
+     */
+    name: string;
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    /**
+     * Factory input value.
+     */
+    args: {
+        [k: string]: unknown | undefined;
+    };
+}
+/**
+ * Result returned by an extension factory closure.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryExecuteResult".
+ */
+/** @experimental */
+export interface FactoryExecuteResult {
+    /**
+     * Factory result value.
+     */
+    result: {
+        [k: string]: unknown | undefined;
+    };
+}
+/**
+ * Parameters for retrieving a factory run.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryGetRunRequest".
+ */
+/** @experimental */
+export interface FactoryGetRunRequest {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+}
+/**
+ * Parameters for reading a factory journal entry.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryJournalGetRequest".
+ */
+/** @experimental */
+export interface FactoryJournalGetRequest {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    /**
+     * Namespaced journal key.
+     */
+    key: string;
+}
+/**
+ * Result of reading a factory journal entry.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryJournalGetResult".
+ */
+/** @experimental */
+export interface FactoryJournalGetResult {
+    /**
+     * Whether the journal contained the requested key.
+     */
+    hit: boolean;
+    /**
+     * Cached JSON result. The hit field distinguishes a cached JSON null from a miss.
+     */
+    resultJson?: {
+        [k: string]: unknown | undefined;
+    };
+}
+/**
+ * Parameters for storing a factory journal entry.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryJournalPutRequest".
+ */
+/** @experimental */
+export interface FactoryJournalPutRequest {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    /**
+     * Namespaced journal key.
+     */
+    key: string;
+    /**
+     * JSON result to memoize.
+     */
+    resultJson: {
+        [k: string]: unknown | undefined;
+    };
+}
+/**
+ * One ordered factory progress line.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryLogLine".
+ */
+/** @experimental */
+export interface FactoryLogLine {
+    /**
+     * Monotonic sequence number within the factory run.
+     */
+    seq: number;
+    kind: FactoryLogLineKind;
+    /**
+     * Progress text.
+     */
+    text: string;
+}
+/**
+ * Parameters for recording factory progress.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryLogRequest".
+ */
+/** @experimental */
+export interface FactoryLogRequest {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    /**
+     * Ordered progress lines to append.
+     */
+    lines: FactoryLogLine[];
+}
+/**
+ * Wire-only per-invocation factory resource ceiling overrides.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunLimits".
+ */
+/** @experimental */
+export interface FactoryRunLimits {
+    /**
+     * Maximum number of factory subagents that may run concurrently.
+     */
+    maxConcurrentSubagents?: number;
+    /**
+     * Maximum total number of factory subagents that may be admitted.
+     */
+    maxTotalSubagents?: number;
+    /**
+     * Factory active-run timeout in milliseconds.
+     */
+    timeout?: number;
+}
+/**
+ * Parameters for invoking a registered factory.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunRequest".
+ */
+/** @experimental */
+export interface FactoryRunRequest {
+    /**
+     * Registered factory name.
+     */
+    name: string;
+    /**
+     * Factory input value.
+     */
+    args: {
+        [k: string]: unknown | undefined;
+    };
+    options?: RunOptions;
+}
+/**
+ * Options controlling factory invocation.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "RunOptions".
+ */
+/** @experimental */
+export interface RunOptions {
+    limits?: FactoryRunLimits;
+    /**
+     * Run identifier whose journal and progress should seed this resumed run.
+     */
+    resumeFromRunId?: string;
+}
+/**
+ * Complete current or terminal factory run envelope.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "FactoryRunResult".
+ */
+/** @experimental */
+export interface FactoryRunResult {
+    /**
+     * Factory run identifier.
+     */
+    runId: string;
+    status: FactoryRunStatus;
+    /**
+     * Completed factory result.
+     */
+    result?: {
+        [k: string]: unknown | undefined;
+    };
+    /**
+     * Error message for an errored run.
+     */
+    error?: string;
+    failure?: FactoryRunFailure;
+    /**
+     * Reason for a halted or cancelled run.
+     */
+    reason?: string;
+    /**
+     * Partial journal and progress snapshot for a halted, cancelled, or errored run.
+     */
+    snapshot?: {
+        [k: string]: unknown | undefined;
+    };
+}
 /**
  * Optional user prompt to combine with the fleet orchestration instructions.
  *
@@ -5236,13 +5643,17 @@ export interface LlmInferenceHttpRequestStartRequest {
     headers: LlmInferenceHeaders;
     transport?: LlmInferenceHttpRequestStartTransport;
     /**
-     * Stable per-agent-instance id attributing this request to a specific agent trajectory. Present when the request originates from an agent turn; absent for requests issued outside any agent context (e.g. some SDK callers). A request with an `agentId` but no `parentAgentId` is a root-agent request; one carrying both is a subagent request. Sourced from the runtime's per-request agent context and surfaced on the envelope independently of transport, so it is available for both first-party (CAPI) and BYOK/custom-provider requests; on the CAPI transport the runtime derives the upstream `X-Agent-Task-Id` header from this same context. Consumers routing each provider call to a training trajectory should key on this rather than on lifecycle events, since it is available on the request path before sampling.
+     * Stable identity of the agent trajectory that issued this request. Present when the request originates from an agent turn; absent for requests outside any agent context. This is the same identity used by lifecycle and bridged session events and remains constant across turns and retries.
      */
     agentId?: string;
     /**
-     * Id of the parent agent that spawned the agent issuing this request. Present only for subagent requests; absent for root-agent requests and non-agent requests. Combined with `agentId`, this lets consumers attribute a call to a child trajectory versus the root. Like `agentId`, it comes from the runtime's per-request agent context independently of transport; on the CAPI transport the runtime derives the upstream `X-Parent-Agent-Id` header from this same context.
+     * Stable identity of the immediate parent trajectory. Present for child trajectories such as subagents and conversation-sampling requests; absent for root-agent and non-agent requests.
      */
     parentAgentId?: string;
+    /**
+     * Identity of the agent invocation (one agentic loop) that issued this request. It remains fixed across physical retries within the invocation and is distinct from the stable trajectory `agentId`. A caller-supplied invocation id always takes precedence (this covers auxiliary calls that have no model call id). Otherwise, first-party CAPI requests fall back to the runtime's agent task id — the same value the runtime emits as the `X-Agent-Task-Id` header — while custom-provider requests fall back to the model call id.
+     */
+    agentInvocationId?: string;
     /**
      * Coarse classification of the interaction that produced this request. Open string for forward-compatibility; known values include `conversation-agent`, `conversation-subagent`, `conversation-sampling`, `conversation-background`, `conversation-compaction`, and `conversation-user`. Absent when the runtime did not classify the request. Comes from the runtime's per-request agent context independently of transport; on the CAPI transport the runtime derives the upstream `X-Interaction-Type` header from this same context.
      */
@@ -7132,7 +7543,7 @@ export interface SessionWorkingDirectoryContext {
     baseCommit?: string;
 }
 /**
- * Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode).
+ * Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "MetadataRecordContextChangeResult".
@@ -10627,6 +11038,14 @@ export interface SandboxConfig {
      * Whether to auto-add the current working directory to readwritePaths. Default: true.
      */
     addCurrentWorkingDirectory?: boolean;
+    /**
+     * Whether to inject the Copilot GitHub token as an `http.<host>.extraheader` so authenticated HTTPS git works inside the sandbox without the shell-based credential helper the sandbox blocks. Default: false (opt-in).
+     */
+    gitAuth?: boolean;
+    /**
+     * Whether to export `GH_TOKEN` so the `gh` CLI authenticates inside the sandbox without the OS keyring the sandbox blocks. Default: false (opt-in).
+     */
+    ghAuth?: boolean;
 }
 /**
  * User-managed sandbox policy fragment merged into the auto-discovered base policy.
@@ -11064,6 +11483,10 @@ export interface ServerSkillList {
      * All discovered skills across all sources
      */
     skills: ServerSkill[];
+    /**
+     * Messages for skills that failed to load (e.g. malformed SKILL.md). Empty when host skills are excluded so host-local paths are not disclosed to multitenant callers.
+     */
+    errors?: string[];
 }
 /**
  * Current activity flags for the session.
@@ -14844,6 +15267,10 @@ export interface UsageMetricsCodeChanges {
 export interface UsageMetricsModelMetric {
     requests: UsageMetricsModelMetricRequests;
     usage: UsageMetricsModelMetricUsage;
+    /**
+     * Latest known prompt-cache expiration for this model. A timestamp in the past indicates that the observed cache has expired.
+     */
+    cacheExpiresAt?: string;
     /**
      * Accumulated nano-AI units cost for this model
      */
@@ -16013,6 +16440,68 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
         };
     };
     /** @experimental */
+    factory: {
+        /**
+         * Runs a registered factory by name at the top level.
+         *
+         * @param params Parameters for invoking a registered factory.
+         *
+         * @returns Complete current or terminal factory run envelope.
+         */
+        run: (params: FactoryRunRequest) => Promise<FactoryRunResult>;
+        /**
+         * Gets the current or settled envelope for a factory run.
+         *
+         * @param params Parameters for retrieving a factory run.
+         *
+         * @returns Complete current or terminal factory run envelope.
+         */
+        getRun: (params: FactoryGetRunRequest) => Promise<FactoryRunResult>;
+        /**
+         * Requests cancellation of a factory run and returns its run envelope.
+         *
+         * @param params Parameters for cancelling a factory run.
+         *
+         * @returns Complete current or terminal factory run envelope.
+         */
+        cancel: (params: FactoryCancelRequest) => Promise<FactoryRunResult>;
+        /**
+         * Records a batch of ordered factory progress lines.
+         *
+         * @param params Parameters for recording factory progress.
+         *
+         * @returns Acknowledgement that a factory request was accepted.
+         */
+        log: (params: FactoryLogRequest) => Promise<FactoryAckResult>;
+        /**
+         * Runs one factory-scoped subagent and returns its result.
+         *
+         * @param params Parameters for one factory-scoped subagent call.
+         *
+         * @returns Result of one factory-scoped subagent call.
+         */
+        agent: (params: FactoryAgentRequest) => Promise<FactoryAgentResult>;
+        /** @experimental */
+        journal: {
+            /**
+             * Reads a memoized factory journal entry.
+             *
+             * @param params Parameters for reading a factory journal entry.
+             *
+             * @returns Result of reading a factory journal entry.
+             */
+            get: (params: FactoryJournalGetRequest) => Promise<FactoryJournalGetResult>;
+            /**
+             * Stores a memoized factory journal entry.
+             *
+             * @param params Parameters for storing a factory journal entry.
+             *
+             * @returns Acknowledgement that a factory request was accepted.
+             */
+            put: (params: FactoryJournalPutRequest) => Promise<FactoryAckResult>;
+        };
+    };
+    /** @experimental */
     model: {
         /**
          * Gets the currently selected model for the session.
@@ -17045,11 +17534,11 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
          */
         getContextHeaviestMessages: (params: MetadataContextHeaviestMessagesRequest) => Promise<MetadataContextHeaviestMessagesResult>;
         /**
-         * Records a working-directory/git context change and emits a `session.context_changed` event.
+         * Records a working-directory/git context change and emits a `session.context_changed` event. For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event): a local session's working directory is authoritative and is moved via `metadata.setWorkingDirectory` (or an SDK `session.resume` that supplies a `workingDirectory`), not by this method.
          *
          * @param params Updated working-directory/git context to record on the session.
          *
-         * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode).
+         * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.
          */
         recordContextChange: (params: MetadataRecordContextChangeRequest) => Promise<MetadataRecordContextChangeResult>;
         /**
@@ -17272,6 +17761,26 @@ export interface ProviderTokenHandler {
      */
     getToken(params: ProviderTokenAcquireRequest): Promise<ProviderTokenAcquireResult>;
 }
+/** Handler for `factory` client session API methods. */
+/** @experimental */
+export interface FactoryHandler {
+    /**
+     * Asks the owning extension connection to execute a registered factory closure.
+     *
+     * @param params Parameters sent to the owning extension to execute a factory closure.
+     *
+     * @returns Result returned by an extension factory closure.
+     */
+    execute(params: FactoryExecuteRequest): Promise<FactoryExecuteResult>;
+    /**
+     * Asks the owning extension connection to abort a running factory cooperatively.
+     *
+     * @param params Parameters for cooperatively aborting a factory body.
+     *
+     * @returns Acknowledgement that a factory request was accepted.
+     */
+    abort(params: FactoryAbortRequest): Promise<FactoryAckResult>;
+}
 /** Handler for `sessionFs` client session API methods. */
 /** @experimental */
 export interface SessionFsHandler {
@@ -17401,6 +17910,7 @@ export interface CanvasHandler {
 /** All client session API handler groups. */
 export interface ClientSessionApiHandlers {
     providerToken?: ProviderTokenHandler;
+    factory?: FactoryHandler;
     sessionFs?: SessionFsHandler;
     canvas?: CanvasHandler;
 }

package/dist/generated/rpc.js

@@ -734,6 +734,68 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    factory: {
+      /**
+       * Runs a registered factory by name at the top level.
+       *
+       * @param params Parameters for invoking a registered factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
+      /**
+       * Gets the current or settled envelope for a factory run.
+       *
+       * @param params Parameters for retrieving a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
+      /**
+       * Requests cancellation of a factory run and returns its run envelope.
+       *
+       * @param params Parameters for cancelling a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Records a batch of ordered factory progress lines.
+       *
+       * @param params Parameters for recording factory progress.
+       *
+       * @returns Acknowledgement that a factory request was accepted.
+       */
+      log: async (params) => connection.sendRequest("session.factory.log", { sessionId, ...params }),
+      /**
+       * Runs one factory-scoped subagent and returns its result.
+       *
+       * @param params Parameters for one factory-scoped subagent call.
+       *
+       * @returns Result of one factory-scoped subagent call.
+       */
+      agent: async (params) => connection.sendRequest("session.factory.agent", { sessionId, ...params }),
+      /** @experimental */
+      journal: {
+        /**
+         * Reads a memoized factory journal entry.
+         *
+         * @param params Parameters for reading a factory journal entry.
+         *
+         * @returns Result of reading a factory journal entry.
+         */
+        get: async (params) => connection.sendRequest("session.factory.journal.get", { sessionId, ...params }),
+        /**
+         * Stores a memoized factory journal entry.
+         *
+         * @param params Parameters for storing a factory journal entry.
+         *
+         * @returns Acknowledgement that a factory request was accepted.
+         */
+        put: async (params) => connection.sendRequest("session.factory.journal.put", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     model: {
       /**
        * Gets the currently selected model for the session.
@@ -1766,11 +1828,11 @@ function createSessionRpc(connection, sessionId) {
        */
       getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { sessionId, ...params }),
       /**
-       * Records a working-directory/git context change and emits a `session.context_changed` event.
+       * Records a working-directory/git context change and emits a `session.context_changed` event. For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event): a local session's working directory is authoritative and is moved via `metadata.setWorkingDirectory` (or an SDK `session.resume` that supplies a `workingDirectory`), not by this method.
        *
        * @param params Updated working-directory/git context to record on the session.
        *
-       * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode).
+       * @returns Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.
        */
       recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { sessionId, ...params }),
       /**
@@ -2040,6 +2102,16 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
     return handler.getToken(params);
   });
+  connection.onRequest("factory.execute", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.execute(params);
+  });
+  connection.onRequest("factory.abort", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.abort(params);
+  });
   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}`);

package/dist/generated/session-events.d.ts

@@ -5,7 +5,7 @@
 /**
  * Union of all session event variants emitted by the Copilot CLI runtime.
  */
-export type SessionEvent = StartEvent | ResumeEvent | RemoteSteerableChangedEvent | ErrorEvent | IdleEvent | TitleChangedEvent | ScheduleCreatedEvent | ScheduleCancelledEvent | ScheduleRearmedEvent | AutopilotObjectiveChangedEvent | InfoEvent | WarningEvent | ModelChangeEvent | ModeChangedEvent | SessionLimitsChangedEvent | PermissionsChangedEvent | PlanChangedEvent | TodosChangedEvent | WorkspaceFileChangedEvent | HandoffEvent | TruncationEvent | SnapshotRewindEvent | ShutdownEvent | UsageCheckpointEvent | ContextChangedEvent | UsageInfoEvent | CompactionStartEvent | CompactionCompleteEvent | TaskCompleteEvent | UserMessageEvent | PendingMessagesModifiedEvent | AssistantTurnStartEvent | AssistantIntentEvent | AssistantServerToolProgressEvent | AssistantReasoningEvent | AssistantReasoningDeltaEvent | AssistantToolCallDeltaEvent | AssistantStreamingDeltaEvent | AssistantMessageEvent | AssistantMessageStartEvent | AssistantMessageDeltaEvent | AssistantTurnEndEvent | AssistantIdleEvent | AssistantUsageEvent | ModelCallFailureEvent | AbortEvent | ToolUserRequestedEvent | ToolExecutionStartEvent | ToolExecutionPartialResultEvent | ToolExecutionProgressEvent | ToolExecutionCompleteEvent | SkillInvokedEvent | SubagentStartedEvent | SubagentCompletedEvent | SubagentFailedEvent | SubagentSelectedEvent | SubagentDeselectedEvent | HookStartEvent | HookEndEvent | HookProgressEvent | BinaryAssetEvent | SystemMessageEvent | SystemNotificationEvent | PermissionRequestedEvent | PermissionCompletedEvent | UserInputRequestedEvent | UserInputCompletedEvent | ElicitationRequestedEvent | ElicitationCompletedEvent | SamplingRequestedEvent | SamplingCompletedEvent | McpOauthRequiredEvent | McpOauthCompletedEvent | McpHeadersRefreshRequiredEvent | McpHeadersRefreshCompletedEvent | CustomNotificationEvent | ExternalToolRequestedEvent | ExternalToolCompletedEvent | CommandQueuedEvent | CommandExecuteEvent | CommandCompletedEvent | AutoModeSwitchRequestedEvent | AutoModeSwitchCompletedEvent | SessionLimitsExhaustedRequestedEvent | SessionLimitsExhaustedCompletedEvent | AutoModeResolvedEvent | ManagedSettingsResolvedEvent | CommandsChangedEvent | CapabilitiesChangedEvent | ExitPlanModeRequestedEvent | ExitPlanModeCompletedEvent | ToolsUpdatedEvent | BackgroundTasksChangedEvent | SkillsLoadedEvent | CustomAgentsUpdatedEvent | McpServersLoadedEvent | McpServerStatusChangedEvent | McpToolsListChangedEvent | McpResourcesListChangedEvent | McpPromptsListChangedEvent | ExtensionsLoadedEvent | CanvasOpenedEvent | CanvasRegistryChangedEvent | CanvasClosedEvent | CanvasUnavailableEvent | CanvasRecordedEvent | CanvasRemovedEvent | ExtensionsAttachmentsPushedEvent | McpAppToolCallCompleteEvent;
+export type SessionEvent = StartEvent | ResumeEvent | RemoteSteerableChangedEvent | ErrorEvent | IdleEvent | TitleChangedEvent | ScheduleCreatedEvent | ScheduleCancelledEvent | ScheduleRearmedEvent | AutopilotObjectiveChangedEvent | InfoEvent | WarningEvent | ModelChangeEvent | ModeChangedEvent | SessionLimitsChangedEvent | PermissionsChangedEvent | PlanChangedEvent | TodosChangedEvent | WorkspaceFileChangedEvent | HandoffEvent | TruncationEvent | SnapshotRewindEvent | ShutdownEvent | UsageCheckpointEvent | ContextChangedEvent | UsageInfoEvent | CompactionStartEvent | CompactionCompleteEvent | TaskCompleteEvent | UserMessageEvent | PendingMessagesModifiedEvent | AssistantTurnStartEvent | AssistantTurnRetryEvent | AssistantIntentEvent | AssistantServerToolProgressEvent | AssistantReasoningEvent | AssistantReasoningDeltaEvent | AssistantToolCallDeltaEvent | AssistantStreamingDeltaEvent | AssistantMessageEvent | AssistantMessageStartEvent | AssistantMessageDeltaEvent | AssistantTurnEndEvent | AssistantIdleEvent | AssistantUsageEvent | ModelCallFailureEvent | ModelCallStartEvent | AbortEvent | ToolUserRequestedEvent | ToolExecutionStartEvent | ToolExecutionPartialResultEvent | ToolExecutionProgressEvent | ToolExecutionCompleteEvent | ToolSearchActivatedEvent | SkillInvokedEvent | SubagentStartedEvent | SubagentCompletedEvent | SubagentFailedEvent | SubagentSelectedEvent | SubagentDeselectedEvent | HookStartEvent | HookEndEvent | HookProgressEvent | BinaryAssetEvent | SystemMessageEvent | SystemNotificationEvent | PermissionRequestedEvent | PermissionCompletedEvent | UserInputRequestedEvent | UserInputCompletedEvent | ElicitationRequestedEvent | ElicitationCompletedEvent | SamplingRequestedEvent | SamplingCompletedEvent | McpOauthRequiredEvent | McpOauthCompletedEvent | McpHeadersRefreshRequiredEvent | McpHeadersRefreshCompletedEvent | CustomNotificationEvent | ExternalToolRequestedEvent | ExternalToolCompletedEvent | CommandQueuedEvent | CommandExecuteEvent | CommandCompletedEvent | AutoModeSwitchRequestedEvent | AutoModeSwitchCompletedEvent | SessionLimitsExhaustedRequestedEvent | SessionLimitsExhaustedCompletedEvent | AutoModeResolvedEvent | ManagedSettingsResolvedEvent | ManagedSettingsEnforcedEvent | CommandsChangedEvent | CapabilitiesChangedEvent | ExitPlanModeRequestedEvent | ExitPlanModeCompletedEvent | ToolsUpdatedEvent | BackgroundTasksChangedEvent | SkillsLoadedEvent | CustomAgentsUpdatedEvent | McpServersLoadedEvent | McpServerStatusChangedEvent | McpToolsListChangedEvent | McpResourcesListChangedEvent | McpPromptsListChangedEvent | ExtensionsLoadedEvent | CanvasOpenedEvent | CanvasRegistryChangedEvent | CanvasClosedEvent | CanvasUnavailableEvent | CanvasRecordedEvent | CanvasRemovedEvent | ExtensionsAttachmentsPushedEvent | McpAppToolCallCompleteEvent;
 /**
  * Hosting platform type of the repository (github or ado)
  */
@@ -207,6 +207,14 @@ export type ModelCallFailureBadRequestKind =
 "bodyless"
 /** The 400 response carried a structured CAPI error envelope (deterministic validation failure). */
  | "structured_error";
+/**
+ * Boundary that produced a model call failure
+ */
+export type ModelCallFailureKind = 
+/** The provider returned an API error response. */
+"api"
+/** The request transport failed before a usable API response completed. */
+ | "transport";
 /**
  * Where the failed model call originated
  */
@@ -217,6 +225,14 @@ export type ModelCallFailureSource =
  | "subagent"
 /** Model call from MCP sampling. */
  | "mcp_sampling";
+/**
+ * Transport used for a failed model call
+ */
+export type ModelCallFailureTransport = 
+/** HTTP transport, including SSE streams. */
+"http"
+/** WebSocket transport. */
+ | "websocket";
 /**
  * Finite reason code describing why the current turn was aborted
  */
@@ -481,6 +497,26 @@ export type ManagedSettingsResolvedSource =
  | "device"
 /** No managed policy is in force (no layer contributed). */
  | "none";
+/**
+ * The category of runtime action that enterprise managed settings governed (blocked or capped)
+ */
+export type ManagedSettingsEnforcedAction = 
+/** An attempt to turn on a bypass-permissions ("yolo") escalation was refused or capped because policy disables bypass-permissions mode. */
+"bypass_permissions_blocked";
+/**
+ * For a `bypass_permissions_blocked` action, which permission-escalation primitive was refused
+ */
+export type ManagedSettingsEnforcedEscalation = 
+/** Full allow-all ("/allow-all on") permissions — auto-approving tools, paths, and URLs. */
+"allow_all"
+/** Auto-approval of all tool permission requests. */
+ | "approve_all"
+/** Advisory auto-approval ("/allow-all auto") mode — keeps normal prompt paths and adds LLM-advised approval, distinct from full allow-all. */
+ | "auto_approval"
+/** Unrestricted filesystem access outside the session's allowed directories. */
+ | "unrestricted_paths"
+/** Unrestricted URL fetch access. */
+ | "unrestricted_urls";
 /**
  * Exit plan mode action
  */
@@ -2914,6 +2950,23 @@ export interface AssistantTurnStartData {
      */
     turnId: string;
 }
+/**
+ * Metadata for an additional model inference attempt within an existing assistant turn
+ */
+export interface AssistantTurnRetryData {
+    /**
+     * Model identifier used for this retry, when known
+     */
+    model?: string;
+    /**
+     * Provider or runtime classification that caused the retry, when known
+     */
+    reason?: string;
+    /**
+     * Identifier of the turn whose model inference is being retried
+     */
+    turnId: string;
+}
 /**
  * Session event "assistant.intent". Agent intent description for current activity or plan
  */
@@ -3675,6 +3728,10 @@ export interface AssistantUsageData {
      */
     apiCallId?: string;
     apiEndpoint?: AssistantUsageApiEndpoint;
+    /**
+     * Updated prompt-cache expiration for this model call. Present only when the call establishes or refreshes known cache state.
+     */
+    cacheExpiresAt?: string;
     /**
      * Number of tokens read from prompt cache
      */
@@ -3816,6 +3873,7 @@ export interface ModelCallFailureData {
      * Completion ID from the model provider (e.g., chatcmpl-abc123)
      */
     apiCallId?: string;
+    apiEndpoint?: AssistantUsageApiEndpoint;
     badRequestKind?: ModelCallFailureBadRequestKind;
     /**
      * Duration of the failed API call in milliseconds
@@ -3833,10 +3891,27 @@ export interface ModelCallFailureData {
      * For HTTP 400 failures only: the `type` from the CAPI error envelope (e.g. 'websocket_error'), a coarser companion to errorCode for envelopes that carry no code. Raw server-controlled string, emitted only through restricted telemetry. Absent for bodyless or non-400 failures.
      */
     errorType?: string;
+    failureKind?: ModelCallFailureKind;
     /**
      * What initiated this API call (e.g., "sub-agent", "mcp-sampling"); absent for user-initiated calls
      */
     initiator?: string;
+    /**
+     * Whether the session selected Auto mode for the failed call
+     */
+    isAuto?: boolean;
+    /**
+     * Whether the failed call used a bring-your-own-key provider
+     */
+    isByok?: boolean;
+    /**
+     * Effective maximum output-token limit for the failed call
+     */
+    maxOutputTokens?: number;
+    /**
+     * Effective maximum prompt-token limit for the failed call
+     */
+    maxPromptTokens?: number;
     /**
      * Model identifier used for the failed API call
      */
@@ -3845,6 +3920,10 @@ export interface ModelCallFailureData {
      * GitHub request tracing ID (x-github-request-id header) for server-side log correlation
      */
     providerCallId?: string;
+    /**
+     * Reasoning effort level used for the failed model call, if applicable
+     */
+    reasoningEffort?: string;
     requestFingerprint?: ModelCallFailureRequestFingerprint;
     /**
      * Copilot service request ID (x-copilot-service-request-id header) for CAPI log correlation
@@ -3855,6 +3934,7 @@ export interface ModelCallFailureData {
      * HTTP status code from the failed request
      */
     statusCode?: number;
+    transport?: ModelCallFailureTransport;
 }
 /**
  * Content-free structural summary of the failing request for diagnosing malformed 4xx calls
@@ -3889,6 +3969,19 @@ export interface ModelCallFailureRequestFingerprint {
      */
     toolResultMessageCount: number;
 }
+/**
+ * Model API dispatch metadata for internal telemetry
+ */
+export interface ModelCallStartData {
+    /**
+     * Model identifier used for this API call, when known
+     */
+    model?: string;
+    /**
+     * Identifier of the assistant turn that initiated the model call
+     */
+    turnId: string;
+}
 /**
  * Session event "abort". Turn abort information including the reason for termination
  */
@@ -4734,6 +4827,49 @@ export interface ToolExecutionCompleteToolDescriptionMetaUI {
      */
     visibility?: ToolExecutionCompleteToolDescriptionMetaUIVisibility[];
 }
+/**
+ * Session event "tool_search.activated". Persisted generic client-side tool activations restored when a session resumes.
+ */
+export interface ToolSearchActivatedEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: ToolSearchActivatedData;
+    /**
+     * When true, the event is transient and not persisted to the session event log on disk
+     */
+    ephemeral?: boolean;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "tool_search.activated".
+     */
+    type: "tool_search.activated";
+}
+/**
+ * Persisted generic client-side tool activations restored when a session resumes.
+ */
+export interface ToolSearchActivatedData {
+    /**
+     * Tool-search strategy that activated the definitions.
+     */
+    strategy: string;
+    /**
+     * Names of tool definitions activated by this search invocation.
+     */
+    toolNames: string[];
+}
 /**
  * Session event "skill.invoked". Skill invocation details including content, allowed tools, and plugin metadata
  */
@@ -7739,6 +7875,57 @@ export interface ManagedSettingsResolvedData {
     };
     source: ManagedSettingsResolvedSource;
 }
+/**
+ * Session event "session.managed_settings_enforced". Runtime enforcement of enterprise managed settings: fires when the session blocks or caps a runtime action because enterprise policy governs it, so SDK clients can explain *why* an action was governed. Unlike `session.managed_settings_resolved` (which reports *what* is managed), this reports a concrete governed action — e.g. a user or host tried to turn on a bypass-permissions escalation while policy disables it. Emitted live (not persisted to the session event log) on user/host-initiated attempts only, never for silent policy application. Marked experimental while the managed-settings surface stabilizes.
+ */
+/** @experimental */
+export interface ManagedSettingsEnforcedEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: ManagedSettingsEnforcedData;
+    /**
+     * Always true for events that are transient and not persisted to the session event log on disk.
+     */
+    ephemeral: true;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "session.managed_settings_enforced".
+     */
+    type: "session.managed_settings_enforced";
+}
+/**
+ * Runtime enforcement of enterprise managed settings: fires when the session blocks or caps a runtime action because enterprise policy governs it, so SDK clients can explain *why* an action was governed. Unlike `session.managed_settings_resolved` (which reports *what* is managed), this reports a concrete governed action — e.g. a user or host tried to turn on a bypass-permissions escalation while policy disables it. Emitted live (not persisted to the session event log) on user/host-initiated attempts only, never for silent policy application. Marked experimental while the managed-settings surface stabilizes.
+ */
+/** @experimental */
+export interface ManagedSettingsEnforcedData {
+    action: ManagedSettingsEnforcedAction;
+    escalation?: ManagedSettingsEnforcedEscalation;
+    /**
+     * Whether the enforcement was forced by fail-closed handling (managed policy could not be determined) rather than an explicit managed setting. When true, `setting` still names the restriction that was applied.
+     */
+    failClosed: boolean;
+    /**
+     * A human-readable explanation of why the action was governed, suitable for surfacing to the user.
+     */
+    message: string;
+    /**
+     * The managed setting key responsible for the enforcement (e.g. `permissions.disableBypassPermissionsMode`).
+     */
+    setting: string;
+}
 /**
  * Session event "commands.changed". SDK command registration change notification
  */

package/dist/index.d.ts

@@ -10,4 +10,4 @@ export { CopilotSession, type AssistantMessageEvent } from "./session.js";
 export { Canvas, CanvasError, createCanvas, type CanvasAction, type CanvasDeclaration, type CanvasHostContext, type CanvasHostContextCapabilities, type CanvasJsonSchema, type CanvasOptions, } from "./canvas.js";
 export { defineTool, approveAll, convertMcpCallToolResult, createSessionFsAdapter, CopilotRequestHandler, CopilotWebSocketHandler, CopilotWebSocketCloseStatus, CopilotWebSocketForwarder, SYSTEM_MESSAGE_SECTIONS, } from "./types.js";
 export type * from "./generated/session-events.js";
-export type { CommandContext, CommandDefinition, CommandHandler, CanvasProviderIdentity, CloudSessionOptions, CloudSessionRepository, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, CopilotClientMode, CopilotClientOptions, StdioRuntimeConnection, InProcessRuntimeConnection, TcpRuntimeConnection, UriRuntimeConnection, ChildProcessRuntimeConnection, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ExtensionInfo, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, GitHubTelemetryNotification, GitHubTelemetryEvent, GitHubTelemetryClientInfo, InfiniteSessionConfig, LargeToolOutputConfig, MemoryConfiguration, UiInputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, BearerTokenProvider, MessageOptions, ModelBilling, ModelBillingTokenPrices, ModelBillingTokenPricesLongContext, CapiSessionOptions, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, NamedProviderConfig, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, ProviderModelConfig, ProviderTokenArgs, RemoteSessionMode, ResumeSessionConfig, SectionOverride, SectionOverrideAction, SectionTransformFn, SessionCapabilities, SessionConfig, SessionConfigBase, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventMetadata, SessionLifecycleEventType, SessionLifecycleHandler, SessionCreatedEvent, SessionDeletedEvent, SessionUpdatedEvent, SessionForegroundEvent, SessionBackgroundEvent, SessionContext, SessionListFilter, SessionMetadata, SessionUiApi, SessionFsConfig, SessionFsProvider, SessionFsFileInfo, SessionFsSqliteQueryResult, SessionFsSqliteQueryType, SessionFsSqliteProvider, CopilotRequestContext, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemMessageSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, CurrentToolMetadata, ToolTelemetry, ToolResultObject, ToolSearchConfig, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";
+export type { CommandContext, CommandDefinition, CommandHandler, CanvasProviderIdentity, CloudSessionOptions, CloudSessionRepository, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, CopilotClientMode, CopilotClientOptions, CopilotExpAssignmentResponse, StdioRuntimeConnection, InProcessRuntimeConnection, TcpRuntimeConnection, UriRuntimeConnection, ChildProcessRuntimeConnection, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExpConfigEntry, ExpFlagValue, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ExtensionInfo, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, GitHubTelemetryNotification, GitHubTelemetryEvent, GitHubTelemetryClientInfo, InfiniteSessionConfig, LargeToolOutputConfig, MemoryConfiguration, UiInputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, BearerTokenProvider, MessageOptions, ModelBilling, ModelBillingTokenPrices, ModelBillingTokenPricesLongContext, CapiSessionOptions, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, NamedProviderConfig, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, ProviderModelConfig, ProviderTokenArgs, RemoteSessionMode, ResumeSessionConfig, SectionOverride, SectionOverrideAction, SectionTransformFn, SessionCapabilities, SessionConfig, SessionConfigBase, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventMetadata, SessionLifecycleEventType, SessionLifecycleHandler, SessionCreatedEvent, SessionDeletedEvent, SessionUpdatedEvent, SessionForegroundEvent, SessionBackgroundEvent, SessionContext, SessionListFilter, SessionMetadata, SessionUiApi, SessionFsConfig, SessionFsProvider, SessionFsFileInfo, SessionFsSqliteQueryResult, SessionFsSqliteQueryType, SessionFsSqliteProvider, CopilotRequestContext, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemMessageSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, CurrentToolMetadata, ToolTelemetry, ToolResultObject, ToolSearchConfig, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";

package/dist/types.d.ts

@@ -1300,6 +1300,12 @@ export interface CustomAgentConfig {
      * falling back to the parent session model if unavailable.
      */
     model?: string;
+    /**
+     * Reasoning effort level for this agent's model.
+     * When omitted, no per-agent override is sent and the backend chooses its
+     * default. The parent session effort is not inherited.
+     */
+    reasoningEffort?: ReasoningEffort;
 }
 /**
  * Configuration for the default agent (the built-in agent that handles
@@ -1492,6 +1498,42 @@ export interface CapiSessionOptions {
      */
     enableWebSocketResponses?: boolean;
 }
+/**
+ * A single ExP (Experiment Platform) flag value. ExP assignments resolve to a
+ * string, number, boolean, or `null`.
+ */
+export type ExpFlagValue = string | number | boolean | null;
+/**
+ * A single configuration entry in a {@link CopilotExpAssignmentResponse}. Each
+ * entry carries an identifier and a bag of typed parameter values.
+ */
+export interface ExpConfigEntry {
+    /** Identifier of the configuration entry. */
+    Id: string;
+    /** Parameter values keyed by parameter name. */
+    Parameters: Record<string, ExpFlagValue>;
+}
+/**
+ * ExP ("flight") assignment data, in the same JSON shape the Copilot CLI
+ * fetches from the experimentation service. Field names are PascalCase to match
+ * the on-the-wire contract consumed by the runtime.
+ */
+export interface CopilotExpAssignmentResponse {
+    /** Enabled feature names. */
+    Features: string[];
+    /** Assigned flights keyed by flight name. */
+    Flights: Record<string, string>;
+    /** Configuration entries carrying typed parameter values. */
+    Configs: ExpConfigEntry[];
+    /** Opaque parameter-group payload passed through untouched. */
+    ParameterGroups?: unknown;
+    /** Version of the flighting configuration. */
+    FlightingVersion?: number;
+    /** Impression identifier for the assignment. */
+    ImpressionId?: string;
+    /** Assignment context string forwarded to CAPI and telemetry. */
+    AssignmentContext: string;
+}
 /**
  * Shared configuration fields used by both {@link SessionConfig} (for
  * creating a new session) and {@link ResumeSessionConfig} (for resuming

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/github/copilot-sdk.git"
   },
-  "version": "1.0.7",
+  "version": "1.0.8-preview.0",
   "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
   "main": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
@@ -56,7 +56,7 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@github/copilot": "^1.0.71",
+    "@github/copilot": "^1.0.72",
     "koffi": "^3.1.0",
     "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.3.6"