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

package/dist/generated/rpc.js

@@ -238,13 +238,13 @@ function createServerRpc(connection) {
       /**
        * Enables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to enable.
+       * @param params Plugin names (or specs) to enable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       enable: async (params) => connection.sendRequest("plugins.enable", params),
       /**
        * Disables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to disable.
+       * @param params Plugin names (or specs) to disable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       disable: async (params) => connection.sendRequest("plugins.disable", params),
       /** @experimental */
@@ -494,7 +494,15 @@ function createServerRpc(connection) {
        */
       list: async (params) => connection.sendRequest("sessions.list", params),
       /**
-       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The initial backward read uses a bounded tail scan for fast first paint; cursor continuations preserve the session event-log paging semantics. Persisted events may omit payloads that are reconstructed only for an active session.
+       * Reads client-owned metadata for multiple persisted local sessions without opening them. Results preserve request order and report missing, corrupt, unsupported, or temporarily unavailable sessions independently.
+       *
+       * @param params Bounded batch request for client-owned metadata from persisted local sessions.
+       *
+       * @returns Ordered client metadata outcomes for the requested local sessions.
+       */
+      getClientMetadata: async (params) => connection.sendRequest("sessions.getClientMetadata", params),
+      /**
+       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The first read pins the currently opened journal generation and its byte-length boundary; opaque cursor continuations remain on that generation across runtime-owned compaction, truncation, and rewrite operations, which replace the live path atomically, and events appended after the boundary are excluded. For cold hydration, await the first successful page before activation and establish lossless live-event buffering before resume; merge subsequent live events by ID, preserving persisted order and letting live payloads win. Continuations are process-local, single-use capabilities bound to the originating session and storage context and must be paged sequentially; concurrent or repeated use of the same cursor expires that duplicate read rather than reading the generation twice. A complete snapshot has cursorStatus 'ok' and hasMore false. Snapshots expire after five idle minutes, with at most eight retained per process and idle-only eviction under pressure; completion and cancelled-worker exit release their handles. No transcript copy is created, but retained handles may keep replaced files' disk blocks alive until release. Pages have a soft 1 MiB serialized event-array budget including resolved binary assets; one oversized event is returned alone to guarantee progress. Working memory also includes a record/lookahead and asset resolution; resolving the first binary reference may scan the full pinned generation to build a bounded offset index. If the snapshot expires, is evicted, is cancelled before a continuation is established, or becomes unreadable after an observable unsupported in-place shortening, the continuation returns cursorStatus 'expired' with an empty terminal page and never falls back to a different generation. A missing or initially unreadable journal is an RPC error. Persisted history excludes ephemeral events and may omit payloads that are reconstructed only for an active session; use the active session event stream for post-resume live events.
        *
        * @param params Pagination options for reading an inactive or active local session's persisted event journal.
        *
@@ -775,7 +783,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Managed sandbox enforcement state for a session.
        */
-      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId })
+      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId }),
+      /**
+       * Disables sandboxing for the remainder of the current session and approves the referenced pending sandbox-bypass permission request. The request is rejected unless the exact request is still pending and the effective sandbox policy permits bypass.
+       *
+       * @param params Request to disable sandboxing for the current session while resolving an active sandbox-bypass permission prompt.
+       *
+       * @returns Result of attempting to disable sandboxing for the current session.
+       */
+      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params })
     },
     /**
      * Aborts the current agent turn.
@@ -939,6 +955,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Complete current or terminal factory run envelope.
        */
       cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Pauses a running factory and returns its settled run envelope.
+       *
+       * @param params Parameters for pausing a running factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      pause: async (params) => connection.sendRequest("session.factory.pause", { sessionId, ...params }),
       /**
        * Records a batch of ordered factory progress lines.
        *
@@ -999,6 +1023,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.
        */
       switchAutoTier: async (params) => connection.sendRequest("session.model.switchAutoTier", { sessionId, ...params }),
+      /**
+       * Replaces or clears the host-supplied model allowlist for a running session.
+       *
+       * @param params Host-supplied exact model selection IDs to allow for this running session. CAPI IDs are intersected with repository `.github/allowed_models.txt` policy; provider-qualified IDs remain exempt from repository-only policy but are restricted by this host list. Omit or pass null to clear the host restriction; an explicit empty or disjoint list is rejected. Validation and pre-selection fallback failures preserve the previous restriction. Failures after a fallback selection commits retain the new restriction and selected model; callers should inspect current session state after such an error.
+       *
+       * @returns The applied host allowlist and effective session model policy after intersection.
+       */
+      setAllowedModels: async (params) => connection.sendRequest("session.model.setAllowedModels", { sessionId, ...params }),
       /**
        * Updates the session's reasoning effort without changing the selected model.
        *
@@ -1244,7 +1276,7 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Starts fleet mode by submitting the fleet orchestration prompt to the session.
        *
-       * @param params Optional user prompt to combine with the fleet orchestration instructions.
+       * @param params Parameters for starting fleet orchestration: an optional user prompt combined with the fleet instructions, plus the send options forwarded to the resulting turn.
        *
        * @returns Indicates whether fleet mode was successfully activated.
        */
@@ -1786,7 +1818,7 @@ function createSessionRpc(connection, sessionId) {
        */
       set: async (params) => connection.sendRequest("session.tools.set", { sessionId, ...params }),
       /**
-       * Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
+       * Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
        *
        * @param params Subagent settings to apply to the current session
        *
@@ -2136,6 +2168,20 @@ function createSessionRpc(connection, sessionId) {
        * @returns Point-in-time snapshot of slow-changing session identifier and state fields
        */
       snapshot: async () => connection.sendRequest("session.metadata.snapshot", { sessionId }),
+      /**
+       * Returns the client-owned string metadata persisted with this local session. The metadata is not included in model context, events, telemetry, snapshots, or remote exports.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      getClientMetadata: async () => connection.sendRequest("session.metadata.getClientMetadata", { sessionId }),
+      /**
+       * Atomically patches the client-owned string metadata persisted with this local session and returns the committed bag.
+       *
+       * @param params Atomic patch for client-owned session metadata. Operations apply in clear, remove, then set order. The resulting bag must satisfy the ClientMetadata entry and serialized-size limits. Local storage coordinates concurrent runtime processes; custom SessionFs providers must serialize writers that access the same session from multiple processes.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      updateClientMetadata: async (params) => connection.sendRequest("session.metadata.updateClientMetadata", { sessionId, ...params }),
       /**
        * Reports whether the local session is currently processing user/agent messages.
        *
@@ -2593,7 +2639,13 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Resolved persisted factory identity and resumed run envelope.
        */
-      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params })
+      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params }),
+      /**
+       * Atomically pauses an owned factory attempt at a durable checkpoint.
+       *
+       * @param params Parameters for an owned durable pause checkpoint.
+       */
+      pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
     },
     /** @experimental */
     model: {