@github/copilot-sdk 1.0.7 → 1.0.8

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.
  *
@@ -5199,6 +5606,10 @@ export interface LlmInferenceHttpRequestChunkRequest {
      * Optional human-readable reason for the cancellation, propagated for logging.
      */
     cancelReason?: string;
+    /**
+     * Identity of the agent invocation (one agentic loop) this body chunk belongs to, matching the `agentInvocationId` semantics on httpRequestStart. Carried per chunk so a persistent transport can attribute successive turns correctly: when a WebSocket connection is reused across turns, the httpRequestStart identity reflects only the turn that opened the connection, so each later turn stamps its own invocation id here. Absent when the runtime has no invocation context for the request, or on the plain-HTTP transport where every request has its own httpRequestStart.
+     */
+    agentInvocationId?: string;
 }
 /**
  * Acknowledgement. The SDK is free to ignore the ack and treat chunk delivery as fire-and-forget.
@@ -5236,13 +5647,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 +7547,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 +11042,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 +11487,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 +15271,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 +16444,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 +17538,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 +17765,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 +17914,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",
   "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.73",
     "koffi": "^3.1.0",
     "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.3.6"