@github/copilot-sdk 1.0.8 → 1.0.9-preview.1

package/dist/cjs/generated/rpc.js

@@ -47,7 +47,13 @@ function createServerRpc(connection) {
        *
        * @returns List of Copilot models available to the resolved user, including capabilities and billing metadata.
        */
-      list: async (params) => connection.sendRequest("models.list", params)
+      list: async (params) => connection.sendRequest("models.list", params),
+      /**
+       * Returns the running runtime's complete catalog of well-known built-in model IDs without authentication or network access.
+       *
+       * @returns The running runtime's complete catalog of well-known built-in model IDs, including supported models and additional IDs with built-in metadata.
+       */
+      getBuiltInCatalog: async () => connection.sendRequest("models.getBuiltInCatalog", {})
     },
     /** @experimental */
     tools: {
@@ -606,6 +612,22 @@ function createInternalServerRpc(connection) {
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
     sessions: {
+      /**
+       * Reads lightweight persisted metadata for one local session without opening it.
+       *
+       * @param params Session ID whose persisted metadata should be read.
+       *
+       * @returns Persisted local session metadata when the session exists.
+       */
+      getMetadata: async (params) => connection.sendRequest("sessions.getMetadata", params),
+      /**
+       * Lists recent local session IDs that contain user-visible history, omitting housekeeping-only sessions.
+       *
+       * @param params Limit for non-empty local session IDs.
+       *
+       * @returns Recent local session IDs that contain user-visible history.
+       */
+      listNonEmptySessionIds: async (params) => connection.sendRequest("sessions.listNonEmptySessionIds", params),
       /**
        * Computes the absolute path to a session's persisted events.jsonl file. Internal: filesystem paths are only meaningful in-process (CLI and runtime share a filesystem). Currently used by the CLI's contribution-graph feature to read historical events directly. Remote SDK consumers must not depend on this; a proper event-query API would replace it if the contribution graph ever needed to work over the wire.
        *
@@ -622,6 +644,12 @@ function createInternalServerRpc(connection) {
        * @returns The session's persisted remote-steerable flag, or omitted when no value has been persisted.
        */
       getPersistedRemoteSteerable: async (params) => connection.sendRequest("sessions.getPersistedRemoteSteerable", params),
+      /**
+       * Deletes one local session from disk after running the same lifecycle hooks as the session manager.
+       *
+       * @param params Session ID to delete from disk.
+       */
+      delete: async (params) => connection.sendRequest("sessions.delete", params),
       /**
        * Gets the dynamic-context board entry count associated with a session, when available. Internal: this exists solely so CLI telemetry events (`rem_spawn_gate`, `rem_consolidation_complete`) can pair START / END board counts around the detached rem-agent spawn. "Dynamic context board" is a runtime-internal concept that is not part of the public SDK contract; the long-term plan is to relocate the telemetry emission into the runtime so this method can be deleted entirely.
        *
@@ -685,6 +713,24 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     abort: async (params) => connection.sendRequest("session.abort", { sessionId, ...params }),
+    /**
+     * Interrupts the current main agent turn while leaving running background work (subagents, sidekicks, and promoted attached shells) alive. No-op when the main loop is not processing.
+     *
+     * @param params Parameters for interrupting the main agent turn.
+     *
+     * @returns Result of interrupting the main agent turn.
+     *
+     * @experimental
+     */
+    interruptMainTurn: async (params) => connection.sendRequest("session.interruptMainTurn", { sessionId, ...params }),
+    /**
+     * Cancels every running background agent (task-registry subagents plus sidekick agents) without interrupting the main agent loop. Promoted attached shells are left running.
+     *
+     * @returns The number of running background agents (task-registry agents) that were cancelled.
+     *
+     * @experimental
+     */
+    cancelAllBackgroundAgents: async () => connection.sendRequest("session.cancelAllBackgroundAgents", { sessionId }),
     /**
      * Shuts down the session and persists its final state. Awaits any deferred sessionEnd hooks before resolving so user-supplied hook scripts complete before the runtime tears down.
      *
@@ -771,6 +817,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Complete current or terminal factory run envelope.
        */
       run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
+      /**
+       * Resumes a factory run using its persisted name, arguments, journal, and accounting.
+       *
+       * @param params Parameters for resuming a factory run from its persisted identity.
+       *
+       * @returns Resolved persisted factory identity and resumed run envelope.
+       */
+      resume: async (params) => connection.sendRequest("session.factory.resume", { sessionId, ...params }),
       /**
        * Gets the current or settled envelope for a factory run.
        *
@@ -779,6 +833,28 @@ function createSessionRpc(connection, sessionId) {
        * @returns Complete current or terminal factory run envelope.
        */
       getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
+      /**
+       * Lists durable factory runs for this session in creation order.
+       *
+       * @returns Factory runs in durable creation order.
+       */
+      listRuns: async () => connection.sendRequest("session.factory.listRuns", { sessionId }),
+      /**
+       * Gets durable and live observability detail for one factory run.
+       *
+       * @param params Parameters for retrieving a factory run.
+       *
+       * @returns Full factory run observability detail.
+       */
+      getRunDetail: async (params) => connection.sendRequest("session.factory.getRunDetail", { sessionId, ...params }),
+      /**
+       * Pages durable progress for one factory run.
+       *
+       * @param params Parameters for paging factory progress.
+       *
+       * @returns A bidirectional page of factory progress.
+       */
+      getRunProgress: async (params) => connection.sendRequest("session.factory.getRunProgress", { sessionId, ...params }),
       /**
        * Requests cancellation of a factory run and returns its run envelope.
        *
@@ -933,6 +1009,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
        */
       getWorkspace: async () => connection.sendRequest("session.workspaces.getWorkspace", { sessionId }),
+      /**
+       * Updates workspace metadata for a local session and returns the refreshed workspace.
+       *
+       * @param params Workspace metadata fields to update.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      updateMetadata: async (params) => connection.sendRequest("session.workspaces.updateMetadata", { sessionId, ...params }),
+      /**
+       * Ensures a local session workspace exists and returns it.
+       *
+       * @param params Optional session context used when creating a local workspace.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      ensure: async (params) => connection.sendRequest("session.workspaces.ensure", { sessionId, ...params }),
       /**
        * Lists files stored in the session workspace files directory.
        *
@@ -967,6 +1059,48 @@ function createSessionRpc(connection, sessionId) {
        * @returns Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.
        */
       readCheckpoint: async (params) => connection.sendRequest("session.workspaces.readCheckpoint", { sessionId, ...params }),
+      /**
+       * Adds a compaction summary checkpoint to the local session workspace.
+       *
+       * @param params Compaction summary checkpoint to persist.
+       *
+       * @returns Persisted summary metadata and refreshed workspace metadata.
+       */
+      addSummary: async (params) => connection.sendRequest("session.workspaces.addSummary", { sessionId, ...params }),
+      /**
+       * Truncates local workspace compaction summaries after a rollback.
+       *
+       * @param params Rollback point for local workspace summaries.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      truncateSummaries: async (params) => connection.sendRequest("session.workspaces.truncateSummaries", { sessionId, ...params }),
+      /**
+       * Reads the autopilot objective state file from the local session workspace.
+       *
+       * @returns Autopilot objective file content, or null when missing.
+       */
+      readAutopilotObjective: async () => connection.sendRequest("session.workspaces.readAutopilotObjective", { sessionId }),
+      /**
+       * Writes the autopilot objective state file in the local session workspace.
+       *
+       * @param params Autopilot objective file content to persist.
+       *
+       * @returns Result of writing the autopilot objective file.
+       */
+      writeAutopilotObjective: async (params) => connection.sendRequest("session.workspaces.writeAutopilotObjective", { sessionId, ...params }),
+      /**
+       * Deletes the autopilot objective state file from the local session workspace.
+       *
+       * @returns Result of deleting the autopilot objective file.
+       */
+      deleteAutopilotObjective: async () => connection.sendRequest("session.workspaces.deleteAutopilotObjective", { sessionId }),
+      /**
+       * Checks whether the local session workspace has an autopilot objective state file.
+       *
+       * @returns Whether the autopilot objective file exists.
+       */
+      autopilotObjectiveExists: async () => connection.sendRequest("session.workspaces.autopilotObjectiveExists", { sessionId }),
       /**
        * Saves pasted content as a UTF-8 file in the session workspace.
        *
@@ -976,7 +1110,7 @@ function createSessionRpc(connection, sessionId) {
        */
       saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params }),
       /**
-       * Computes a diff for the session workspace.
+       * Computes a diff for the session workspace. Never rejects for a busy session: a `session`-mode diff that cannot read the session's file-change captures falls back to an unstaged git diff with `isFallback: true` and reports why in `unavailableReason`.
        *
        * @param params Parameters for computing a workspace diff.
        *
@@ -1024,11 +1158,13 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     agent: {
       /**
-       * Lists custom agents available to the session.
+       * Lists agents available to the session. Defaults to custom agents only; pass includeBuiltInAgents to include the effective built-in agents.
+       *
+       * @param params Controls whether built-in agents and authored prompt text are included.
        *
-       * @returns Custom agents available to the session.
+       * @returns Agents available to the session.
        */
-      list: async () => connection.sendRequest("session.agent.list", { sessionId }),
+      list: async (params) => connection.sendRequest("session.agent.list", { sessionId, ...params }),
       /**
        * Gets the currently selected custom agent for the session.
        *
@@ -1235,9 +1371,9 @@ function createSessionRpc(connection, sessionId) {
        */
       removeGitHub: async () => connection.sendRequest("session.mcp.removeGitHub", { sessionId }),
       /**
-       * Starts an individual MCP server on the live session from a caller-supplied config. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.
+       * Starts an individual MCP server on the live session. Omit `config` for a config-free start-by-name of an already-configured server (reuses the server's already-registered configuration); supply `config` to start from a caller-supplied configuration. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.
        *
-       * @param params Server name and configuration for an individual MCP server start.
+       * @param params Server name and optional configuration for an individual MCP server start. Omit `config` for a config-free start-by-name of an already-configured server.
        */
       startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
       /**
@@ -1277,7 +1413,15 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
          */
-        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
+        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params }),
+        /**
+         * Responds to a pending MCP OAuth authorization request by its request id.
+         *
+         * @param params Pending MCP OAuth request id to respond to.
+         *
+         * @returns Indicates whether the pending MCP OAuth response was accepted.
+         */
+        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { sessionId, ...params })
       },
       /** @experimental */
       headers: {
@@ -1693,9 +1837,11 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Clears session-scoped tool permission approvals.
        *
+       * @param params Clears session-scoped tool permission approvals, and optionally the location-scoped ones.
+       *
        * @returns Indicates whether the operation succeeded.
        */
-      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId }),
+      resetSessionApprovals: async (params) => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId, ...params }),
       /**
        * Notifies the runtime that a permission prompt UI has been shown to the user.
        *
@@ -1881,9 +2027,20 @@ function createSessionRpc(connection, sessionId) {
       recomputeContextTokens: async (params) => connection.sendRequest("session.metadata.recomputeContextTokens", { sessionId, ...params })
     },
     /** @experimental */
+    contentExclusion: {
+      /**
+       * Checks local file system absolute paths within the session working directory against its content-exclusion policy. Results preserve input order. Unsupported paths/filesystems and unavailable policy evaluation return available false, and callers must treat every requested path as excluded.
+       *
+       * @param params Local file system absolute paths within the session working directory to check against its content-exclusion policy.
+       *
+       * @returns Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.
+       */
+      checkPaths: async (params) => connection.sendRequest("session.contentExclusion.checkPaths", { sessionId, ...params })
+    },
+    /** @experimental */
     shell: {
       /**
-       * Starts a shell command and streams output through session notifications.
+       * Starts a shell command and streams output through session notifications. The command runs as the leader of its own process group (POSIX) or in a dedicated job object (Windows), so a forced termination — via "shell.kill", the request timeout, or session disposal — signals that whole group/job rather than only the direct child. Two gaps are worth planning for: a command that exits on its own does not trigger that teardown, and on POSIX a descendant that moves itself into a new session or process group (for example via "setsid") leaves the signalled group, so either can leave a background process running.
        *
        * @param params Shell command to run, with optional working directory and timeout in milliseconds.
        *
@@ -1891,7 +2048,7 @@ function createSessionRpc(connection, sessionId) {
        */
       exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
       /**
-       * Sends a signal to a shell process previously started via "shell.exec".
+       * Sends a signal to a shell process previously started via "shell.exec". The signal targets the command's whole process group (POSIX) or job object (Windows), so descendants still in that group are signalled too, not just the direct child. On POSIX a descendant that moved itself into a new session or process group (for example via "setsid") is no longer in the signalled group and survives.
        *
        * @param params Identifier of a process previously returned by "shell.exec" and the signal to send.
        *
@@ -1933,6 +2090,28 @@ function createSessionRpc(connection, sessionId) {
        * @returns Number of events that were removed by the truncation.
        */
       truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params }),
+      /**
+       * Lists the user turns that the session can rewind to. Never rejects for a busy session: rewind reads need the session's file-change captures to be settled, so a session that still holds active work answers with `unavailableReason: "session-busy"` and no points, which the caller can retry.
+       *
+       * @returns Rewind points and file-change-tracking availability for the session.
+       */
+      listRewindPoints: async () => connection.sendRequest("session.history.listRewindPoints", { sessionId }),
+      /**
+       * Previews the files that a conversation-and-files rewind would restore.
+       *
+       * @param params Event boundary to preview for conversation-and-files rewind.
+       *
+       * @returns Files and aggregate changes for a prospective rewind.
+       */
+      previewRewind: async (params) => connection.sendRequest("session.history.previewRewind", { sessionId, ...params }),
+      /**
+       * Rewinds the session conversation, optionally restoring files changed by the discarded turns. Not crash-atomic: file restore and conversation truncation are separate stores, applied in that order, so a process crash between them can leave the workspace rewound while the conversation still contains the discarded turns. There is no recovery journal; re-running the same rewind is the recovery path for a crash before truncation lands, since file restore is idempotent (already-restored files are reported as skipped) and truncation is re-derived from the still-retained boundary event. After truncation lands that boundary no longer exists, so the same request is rejected; the only stage that can still be outstanding is snapshot pruning, whose failure leaves orphan snapshots the capture store tolerates. The reverse inconsistency cannot occur, because truncation is never applied before file restore succeeds.
+       *
+       * @param params Boundary and mode for rewinding session history.
+       *
+       * @returns Structured outcome of a rewind request.
+       */
+      rewind: async (params) => connection.sendRequest("session.history.rewind", { sessionId, ...params }),
       /**
        * Cancels any in-progress background compaction on a local session.
        *
@@ -1960,6 +2139,60 @@ function createSessionRpc(connection, sessionId) {
        * @returns Snapshot of the session's pending queued items and immediate-steering messages.
        */
       pendingItems: async () => connection.sendRequest("session.queue.pendingItems", { sessionId }),
+      /**
+       * Moves an addressable queued item to a public visible position.
+       *
+       * @param params Parameters for moving a queued item by stable id.
+       *
+       * @returns Result of moving a queued item.
+       */
+      moveItem: async (params) => connection.sendRequest("session.queue.moveItem", { sessionId, ...params }),
+      /**
+       * Inserts a new queued message at a public visible position.
+       *
+       * @param params Parameters for inserting a queued message at a public visible position.
+       *
+       * @returns Result of inserting a queued message.
+       */
+      insertAt: async (params) => connection.sendRequest("session.queue.insertAt", { sessionId, ...params }),
+      /**
+       * Removes an addressable queued item by its stable id.
+       *
+       * @param params Parameters for removing a queued item by stable id.
+       *
+       * @returns Result of removing a queued item.
+       */
+      removeAt: async (params) => connection.sendRequest("session.queue.removeAt", { sessionId, ...params }),
+      /**
+       * Updates the text of an addressable single-message queue item.
+       *
+       * @param params Parameters for editing a single queued message.
+       *
+       * @returns Result of editing a queued message.
+       */
+      updateText: async (params) => connection.sendRequest("session.queue.updateText", { sessionId, ...params }),
+      /**
+       * Duplicates an addressable queued item immediately after its source.
+       *
+       * @param params Parameters for duplicating a queued item.
+       *
+       * @returns Result of duplicating a queued item.
+       */
+      duplicateAt: async (params) => connection.sendRequest("session.queue.duplicateAt", { sessionId, ...params }),
+      /**
+       * Acquires or releases the queued-lane drain pause.
+       *
+       * @param params Parameters for acquiring or releasing the queued-lane drain pause. Acquisition is exclusive and non-idempotent: `paused: true` against an already-paused session fails with `queue_already_paused`. The pause is never released automatically — it is not tied to the caller's lifetime, so a client that exits without sending `paused: false` leaves the lane frozen. Release is unowned: `paused: false` clears the pause for any caller, including one that never acquired it.
+       */
+      setDrainPaused: async (params) => connection.sendRequest("session.queue.setDrainPaused", { sessionId, ...params }),
+      /**
+       * Moves an addressable queued message into the live turn's steering lane.
+       *
+       * @param params Parameters for steering a queued message into a live turn.
+       *
+       * @returns Result of trying to steer a queued message into a live turn.
+       */
+      sendNow: async (params) => connection.sendRequest("session.queue.sendNow", { sessionId, ...params }),
       /**
        * Removes the most recently queued user-facing item (LIFO).
        *
@@ -2014,6 +2247,17 @@ function createSessionRpc(connection, sessionId) {
       getMetrics: async () => connection.sendRequest("session.usage.getMetrics", { sessionId })
     },
     /** @experimental */
+    limitPrediction: {
+      /**
+       * Predicts an AI-credit session limit for the session's resolved model. Returns an unavailable result instead of falling back when the current model is unresolved auto.
+       *
+       * @param params Parameters for predicting an AI-credit session limit. Omitting `modelId` uses the session's currently selected model.
+       *
+       * @returns Prediction result. Available results include prediction details; unavailable results include an explicit reason.
+       */
+      predict: async (params) => connection.sendRequest("session.limitPrediction.predict", { sessionId, ...params })
+    },
+    /** @experimental */
     remote: {
       /**
        * Enables remote session export or steering.
@@ -2074,6 +2318,14 @@ function createSessionRpc(connection, sessionId) {
 }
 function createInternalSessionRpc(connection, sessionId) {
   return {
+    /**
+     * Queues or sends an internal system notification to the session according to its passive policy.
+     *
+     * @param params Internal request for sending a system notification.
+     *
+     * @experimental
+     */
+    sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { sessionId, ...params }),
     /** @experimental */
     mcp: {
       /**
@@ -2121,6 +2373,114 @@ function createInternalSessionRpc(connection, sessionId) {
        * @returns Result of evaluating a Rust-owned settings predicate.
        */
       evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
+    },
+    /** @experimental */
+    queue: {
+      /**
+       * Returns the internal native queue snapshot for in-process session orchestration.
+       *
+       * @returns Internal snapshot of native queue state for local session orchestration.
+       */
+      snapshot: async () => connection.sendRequest("session.queue.snapshot", { sessionId }),
+      /**
+       * Reports whether the local session has native queued work pending.
+       *
+       * @returns Whether the native queue has pending work.
+       */
+      hasPending: async () => connection.sendRequest("session.queue.hasPending", { sessionId }),
+      /**
+       * Begins a native deferred-idle drain when background work has quiesced.
+       *
+       * @param params Inputs for starting a deferred-idle drain.
+       *
+       * @returns Whether a deferred-idle drain should run.
+       */
+      beginDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.beginDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.
+       *
+       * @param params Inputs for completing a deferred-idle drain.
+       *
+       * @returns Action selected by the native deferred-idle drain.
+       */
+      finishDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.finishDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Marks session.idle as deferred by native background work state.
+       *
+       * @param params Inputs for marking session.idle deferred in native state.
+       */
+      deferSessionIdle: async (params) => connection.sendRequest("session.queue.deferSessionIdle", { sessionId, ...params }),
+      /**
+       * Consumes queued native system notifications matching an internal filter.
+       *
+       * @param params Internal filter for consuming queued system notifications.
+       *
+       * @returns Indicates whether a user-facing pending item was removed.
+       */
+      consumeSystemNotifications: async (params) => connection.sendRequest("session.queue.consumeSystemNotifications", { sessionId, ...params }),
+      /**
+       * Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.
+       *
+       * @returns Result of enqueueing the resume-pending wake item.
+       */
+      enqueueResumePending: async () => connection.sendRequest("session.queue.enqueueResumePending", { sessionId }),
+      /**
+       * Drains the native local-session work queue for in-process session orchestration.
+       */
+      process: async () => connection.sendRequest("session.queue.process", { sessionId })
+    },
+    /** @experimental */
+    schedule: {
+      /**
+       * Hydrates the native schedule registry from persisted session events.
+       */
+      hydrate: async () => connection.sendRequest("session.schedule.hydrate", { sessionId }),
+      /**
+       * Reports whether the session has an active self-paced scheduled prompt.
+       *
+       * @returns Whether the session currently has an active self-paced schedule.
+       */
+      hasSelfPaced: async () => connection.sendRequest("session.schedule.hasSelfPaced", { sessionId }),
+      /**
+       * Registers a relative-interval scheduled prompt.
+       *
+       * @param params Register a relative-interval scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      add: async (params) => connection.sendRequest("session.schedule.add", { sessionId, ...params }),
+      /**
+       * Registers a recurring cron scheduled prompt.
+       *
+       * @param params Register a cron scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addCron: async (params) => connection.sendRequest("session.schedule.addCron", { sessionId, ...params }),
+      /**
+       * Registers an absolute-time scheduled prompt.
+       *
+       * @param params Register an absolute-time scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addAt: async (params) => connection.sendRequest("session.schedule.addAt", { sessionId, ...params }),
+      /**
+       * Registers a self-paced scheduled prompt.
+       *
+       * @param params Register a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addSelfPaced: async (params) => connection.sendRequest("session.schedule.addSelfPaced", { sessionId, ...params }),
+      /**
+       * Re-arms an active self-paced scheduled prompt.
+       *
+       * @param params Re-arm a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { sessionId, ...params })
     }
   };
 }
@@ -2195,6 +2555,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.sqliteQuery(params);
   });
+  connection.onRequest("sessionFs.sqliteTransaction", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.sqliteTransaction(params);
+  });
   connection.onRequest("sessionFs.sqliteExists", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);

package/dist/cjs/index.js

@@ -27,20 +27,25 @@ __export(index_exports, {
   CopilotWebSocketCloseStatus: () => import_types2.CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder: () => import_types2.CopilotWebSocketForwarder,
   CopilotWebSocketHandler: () => import_types2.CopilotWebSocketHandler,
+  FactoryResumeError: () => import_factory.FactoryResumeError,
   RuntimeConnection: () => import_types.RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS: () => import_types2.SYSTEM_MESSAGE_SECTIONS,
+  SessionFsSqliteTransactionFailure: () => import_types2.SessionFsSqliteTransactionFailure,
   ToolSet: () => import_toolSet.ToolSet,
   approveAll: () => import_types2.approveAll,
   convertMcpCallToolResult: () => import_types2.convertMcpCallToolResult,
   createCanvas: () => import_canvas.createCanvas,
   createSessionFsAdapter: () => import_types2.createSessionFsAdapter,
-  defineTool: () => import_types2.defineTool
+  defineFactory: () => import_factory.defineFactory,
+  defineTool: () => import_types2.defineTool,
+  isFactoryRunTerminal: () => import_factory.isFactoryRunTerminal
 });
 module.exports = __toCommonJS(index_exports);
 var import_client = require("./client.js");
 var import_types = require("./types.js");
 var import_toolSet = require("./toolSet.js");
 var import_session = require("./session.js");
+var import_factory = require("./factory.js");
 var import_canvas = require("./canvas.js");
 var import_types2 = require("./types.js");
 // Annotate the CommonJS export names for ESM import in node:
@@ -54,12 +59,16 @@ var import_types2 = require("./types.js");
   CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder,
   CopilotWebSocketHandler,
+  FactoryResumeError,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,
+  SessionFsSqliteTransactionFailure,
   ToolSet,
   approveAll,
   convertMcpCallToolResult,
   createCanvas,
   createSessionFsAdapter,
-  defineTool
+  defineFactory,
+  defineTool,
+  isFactoryRunTerminal
 });