@github/copilot-sdk 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/index.d.ts

@@ -4,6 +4,8 @@
  * JSON-RPC based SDK for programmatic control of GitHub Copilot CLI
  */
 export { CopilotClient } from "./client.js";
+export { RuntimeConnection } from "./types.js";
 export { CopilotSession, type AssistantMessageEvent } from "./session.js";
 export { defineTool, approveAll, convertMcpCallToolResult, createSessionFsAdapter, SYSTEM_PROMPT_SECTIONS, } from "./types.js";
-export type { CommandContext, CommandDefinition, CommandHandler, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, ConnectionState, CopilotClientOptions, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, InputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, ResumeSessionConfig, SectionOverride, SectionOverrideAction, SectionTransformFn, SessionCapabilities, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionContext, SessionListFilter, SessionMetadata, SessionUiApi, SessionFsConfig, SessionFsProvider, SessionFsFileInfo, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemPromptSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";
+export type * from "./generated/session-events.js";
+export type { CommandContext, CommandDefinition, CommandHandler, CloudSessionOptions, CloudSessionRepository, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, ConnectionState, CopilotClientOptions, StdioRuntimeConnection, TcpRuntimeConnection, UriRuntimeConnection, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, UiInputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, 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, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemPromptSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, ToolTelemetry, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 import { CopilotClient } from "./client.js";
+import { RuntimeConnection } from "./types.js";
 import { CopilotSession } from "./session.js";
 import {
   defineTool,
@@ -10,6 +11,7 @@ import {
 export {
   CopilotClient,
   CopilotSession,
+  RuntimeConnection,
   SYSTEM_PROMPT_SECTIONS,
   approveAll,
   convertMcpCallToolResult,

package/dist/session.d.ts

@@ -1,12 +1,5 @@
-/**
- * Copilot Session - represents a single conversation session with the Copilot CLI.
- * @module session
- */
-import type { MessageConnection } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
-import type { ClientSessionApiHandlers } from "./generated/rpc.js";
-import type { CommandHandler, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, ElicitationHandler, ElicitationContext, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, MessageOptions, PermissionHandler, PermissionRequestResult, ReasoningEffort, ModelCapabilitiesOverride, SectionTransformFn, SessionCapabilities, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, SessionUiApi, Tool, ToolHandler, TraceContextProvider, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.js";
-export declare const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
+import type { MessageOptions, ReasoningEffort, ModelCapabilitiesOverride, SessionCapabilities, SessionEvent, SessionEventHandler, SessionEventType, SessionUiApi, TypedSessionEventHandler } from "./types.js";
 /** Assistant message event - the final response from the assistant. */
 export type AssistantMessageEvent = Extract<SessionEvent, {
     type: "assistant.message";
@@ -54,18 +47,6 @@ export declare class CopilotSession {
     private _rpc;
     private traceContextProvider?;
     private _capabilities;
-    /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
-    clientSessionApis: ClientSessionApiHandlers;
-    /**
-     * Creates a new CopilotSession instance.
-     *
-     * @param sessionId - The unique identifier for this session
-     * @param connection - The JSON-RPC message connection to the Copilot CLI
-     * @param workspacePath - Path to the session workspace directory (when infinite sessions enabled)
-     * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
-     * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
-     */
-    constructor(sessionId: string, connection: MessageConnection, _workspacePath?: string | undefined, traceContextProvider?: TraceContextProvider);
     /**
      * Typed session-scoped RPC methods.
      */
@@ -112,6 +93,7 @@ export declare class CopilotSession {
      * });
      * ```
      */
+    send(prompt: string): Promise<string>;
     send(options: MessageOptions): Promise<string>;
     /**
      * Sends a message to this session and waits until the session becomes idle.
@@ -136,6 +118,7 @@ export declare class CopilotSession {
      * console.log(response?.data.content); // "4"
      * ```
      */
+    sendAndWait(prompt: string, timeout?: number): Promise<AssistantMessageEvent | undefined>;
     sendAndWait(options: MessageOptions, timeout?: number): Promise<AssistantMessageEvent | undefined>;
     /**
      * Subscribes to events from this session.
@@ -183,191 +166,11 @@ export declare class CopilotSession {
      * ```
      */
     on(handler: SessionEventHandler): () => void;
-    /**
-     * Dispatches an event to all registered handlers.
-     * Also handles broadcast request events internally (external tool calls, permissions).
-     *
-     * @param event - The session event to dispatch
-     * @internal This method is for internal use by the SDK.
-     */
-    _dispatchEvent(event: SessionEvent): void;
-    /**
-     * Handles broadcast request events by executing local handlers and responding via RPC.
-     * Handlers are dispatched as fire-and-forget — rejections propagate as unhandled promise
-     * rejections, consistent with standard EventEmitter / event handler semantics.
-     * @internal
-     */
-    private _handleBroadcastEvent;
-    /**
-     * Executes a tool handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executeToolAndRespond;
-    /**
-     * Executes a permission handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executePermissionAndRespond;
-    /**
-     * Executes a command handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executeCommandAndRespond;
-    /**
-     * Registers custom tool handlers for this session.
-     *
-     * Tools allow the assistant to execute custom functions. When the assistant
-     * invokes a tool, the corresponding handler is called with the tool arguments.
-     *
-     * @param tools - An array of tool definitions with their handlers, or undefined to clear all tools
-     * @internal This method is typically called internally when creating a session with tools.
-     */
-    registerTools(tools?: Tool[]): void;
-    /**
-     * Retrieves a registered tool handler by name.
-     *
-     * @param name - The name of the tool to retrieve
-     * @returns The tool handler if found, or undefined
-     * @internal This method is for internal use by the SDK.
-     */
-    getToolHandler(name: string): ToolHandler | undefined;
-    /**
-     * Registers command handlers for this session.
-     *
-     * @param commands - An array of command definitions with handlers, or undefined to clear
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerCommands(commands?: {
-        name: string;
-        handler: CommandHandler;
-    }[]): void;
-    /**
-     * Registers the elicitation handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an elicitation request
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerElicitationHandler(handler?: ElicitationHandler): void;
-    /**
-     * Registers the exit-plan-mode handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an exit-plan-mode request
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerExitPlanModeHandler(handler?: ExitPlanModeHandler): void;
-    /**
-     * Registers the auto-mode-switch handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an auto-mode-switch request
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerAutoModeSwitchHandler(handler?: AutoModeSwitchHandler): void;
-    /**
-     * Handles an elicitation.requested broadcast event.
-     * Invokes the registered handler and responds via handlePendingElicitation RPC.
-     * @internal
-     */
-    _handleElicitationRequest(context: ElicitationContext, requestId: string): Promise<void>;
-    /**
-     * Handles an exitPlanMode.request callback from the runtime.
-     * @internal
-     */
-    _handleExitPlanModeRequest(request: ExitPlanModeRequest): Promise<ExitPlanModeResult>;
-    /**
-     * Handles an autoModeSwitch.request callback from the runtime.
-     * @internal
-     */
-    _handleAutoModeSwitchRequest(request: AutoModeSwitchRequest): Promise<AutoModeSwitchResponse>;
-    /**
-     * Sets the host capabilities for this session.
-     *
-     * @param capabilities - The capabilities object from the create/resume response
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    setCapabilities(capabilities?: SessionCapabilities): void;
     private assertElicitation;
     private _elicitation;
     private _confirm;
     private _select;
     private _input;
-    /**
-     * Registers a handler for permission requests.
-     *
-     * When the assistant needs permission to perform certain actions (e.g., file operations),
-     * this handler is called to approve or deny the request.
-     *
-     * @param handler - The permission handler function, or undefined to remove the handler
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerPermissionHandler(handler?: PermissionHandler): void;
-    /**
-     * Registers a user input handler for ask_user requests.
-     *
-     * When the agent needs input from the user (via ask_user tool),
-     * this handler is called to provide the response.
-     *
-     * @param handler - The user input handler function, or undefined to remove the handler
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerUserInputHandler(handler?: UserInputHandler): void;
-    /**
-     * Registers hook handlers for session lifecycle events.
-     *
-     * Hooks allow custom logic to be executed at various points during
-     * the session lifecycle (before/after tool use, session start/end, etc.).
-     *
-     * @param hooks - The hook handlers object, or undefined to remove all hooks
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerHooks(hooks?: SessionHooks): void;
-    /**
-     * Registers transform callbacks for system message sections.
-     *
-     * @param callbacks - Map of section ID to transform callback, or undefined to clear
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerTransformCallbacks(callbacks?: Map<string, SectionTransformFn>): void;
-    /**
-     * Handles a systemMessage.transform request from the runtime.
-     * Dispatches each section to its registered transform callback.
-     *
-     * @param sections - Map of section IDs to their current rendered content
-     * @returns A promise that resolves with the transformed sections
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleSystemMessageTransform(sections: Record<string, {
-        content: string;
-    }>): Promise<{
-        sections: Record<string, {
-            content: string;
-        }>;
-    }>;
-    /**
-     * Handles a permission request in the v2 protocol format (synchronous RPC).
-     * Used as a back-compat adapter when connected to a v2 server.
-     *
-     * @param request - The permission request data from the CLI
-     * @returns A promise that resolves with the permission decision
-     * @internal This method is for internal use by the SDK.
-     */
-    _handlePermissionRequestV2(request: unknown): Promise<PermissionRequestResult>;
-    /**
-     * Handles a user input request from the Copilot CLI.
-     *
-     * @param request - The user input request data from the CLI
-     * @returns A promise that resolves with the user's response
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleUserInputRequest(request: unknown): Promise<UserInputResponse>;
-    /**
-     * Handles a hooks invocation from the Copilot CLI.
-     *
-     * @param hookType - The type of hook being invoked
-     * @param input - The input data for the hook
-     * @returns A promise that resolves with the hook output, or undefined
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleHooksInvoke(hookType: string, input: unknown): Promise<unknown>;
     /**
      * Retrieves all events and messages from this session's history.
      *
@@ -379,7 +182,7 @@ export declare class CopilotSession {
      *
      * @example
      * ```typescript
-     * const events = await session.getMessages();
+     * const events = await session.getEvents();
      * for (const event of events) {
      *   if (event.type === "assistant.message") {
      *     console.log("Assistant:", event.data.content);
@@ -387,7 +190,7 @@ export declare class CopilotSession {
      * }
      * ```
      */
-    getMessages(): Promise<SessionEvent[]>;
+    getEvents(): Promise<SessionEvent[]>;
     /**
      * Disconnects this session and releases all in-memory resources (event handlers,
      * tool handlers, permission handlers).
@@ -410,16 +213,6 @@ export declare class CopilotSession {
      * ```
      */
     disconnect(): Promise<void>;
-    /**
-     * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
-     *
-     * Disconnects this session and releases all in-memory resources.
-     * Session data on disk is preserved for later resumption.
-     *
-     * @returns A promise that resolves when the session is disconnected
-     * @throws Error if the connection fails
-     */
-    destroy(): Promise<void>;
     /** Enables `await using session = ...` syntax for automatic cleanup. */
     [Symbol.asyncDispose](): Promise<void>;
     /**

package/dist/session.js

@@ -2,6 +2,14 @@ import { ConnectionError, ResponseError } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
 import { getTraceContext } from "./telemetry.js";
 const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
+function deserializeHookInput(raw) {
+  if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
+    return raw;
+  }
+  const obj = raw;
+  const { cwd, ...rest } = obj;
+  return { ...rest, timestamp: new Date(obj.timestamp), workingDirectory: cwd };
+}
 class CopilotSession {
   /**
    * Creates a new CopilotSession instance.
@@ -78,25 +86,8 @@ class CopilotSession {
       input: (message, options) => this._input(message, options)
     };
   }
-  /**
-   * Sends a message to this session and waits for the response.
-   *
-   * The message is processed asynchronously. Subscribe to events via {@link on}
-   * to receive streaming responses and other session events.
-   *
-   * @param options - The message options including the prompt and optional attachments
-   * @returns A promise that resolves with the message ID of the response
-   * @throws Error if the session has been disconnected or the connection fails
-   *
-   * @example
-   * ```typescript
-   * const messageId = await session.send({
-   *   prompt: "Explain this code",
-   *   attachments: [{ type: "file", path: "./src/index.ts" }]
-   * });
-   * ```
-   */
-  async send(options) {
+  async send(optionsOrPrompt) {
+    const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
     const response = await this.connection.sendRequest("session.send", {
       ...await getTraceContext(this.traceContextProvider),
       sessionId: this.sessionId,
@@ -107,30 +98,8 @@ class CopilotSession {
     });
     return response.messageId;
   }
-  /**
-   * Sends a message to this session and waits until the session becomes idle.
-   *
-   * This is a convenience method that combines {@link send} with waiting for
-   * the `session.idle` event. Use this when you want to block until the
-   * assistant has finished processing the message.
-   *
-   * Events are still delivered to handlers registered via {@link on} while waiting.
-   *
-   * @param options - The message options including the prompt and optional attachments
-   * @param timeout - Timeout in milliseconds (default: 60000). Controls how long to wait; does not abort in-flight agent work.
-   * @returns A promise that resolves with the final assistant message when the session becomes idle,
-   *          or undefined if no assistant message was received
-   * @throws Error if the timeout is reached before the session becomes idle
-   * @throws Error if the session has been disconnected or the connection fails
-   *
-   * @example
-   * ```typescript
-   * // Send and wait for completion with default 60s timeout
-   * const response = await session.sendAndWait({ prompt: "What is 2+2?" });
-   * console.log(response?.data.content); // "4"
-   * ```
-   */
-  async sendAndWait(options, timeout) {
+  async sendAndWait(optionsOrPrompt, timeout) {
+    const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
     const effectiveTimeout = timeout ?? 6e4;
     let resolveIdle;
     let rejectWithError;
@@ -373,8 +342,8 @@ class CopilotSession {
   /**
    * Registers custom tool handlers for this session.
    *
-   * Tools allow the assistant to execute custom functions. When the assistant
-   * invokes a tool, the corresponding handler is called with the tool arguments.
+   * Tools with handlers allow the assistant to execute custom functions automatically.
+   * Declaration-only tools are surfaced as events and left pending for the consumer.
    *
    * @param tools - An array of tool definitions with their handlers, or undefined to clear all tools
    * @internal This method is typically called internally when creating a session with tools.
@@ -385,7 +354,9 @@ class CopilotSession {
       return;
     }
     for (const tool of tools) {
-      this.toolHandlers.set(tool.name, tool.handler);
+      if (tool.handler) {
+        this.toolHandlers.set(tool.name, tool.handler);
+      }
     }
   }
   /**
@@ -692,8 +663,10 @@ class CopilotSession {
     if (!this.hooks) {
       return void 0;
     }
+    const normalized = deserializeHookInput(input);
     const handlerMap = {
       preToolUse: this.hooks.onPreToolUse,
+      preMcpToolCall: this.hooks.onPreMcpToolCall,
       postToolUse: this.hooks.onPostToolUse,
       userPromptSubmitted: this.hooks.onUserPromptSubmitted,
       sessionStart: this.hooks.onSessionStart,
@@ -705,7 +678,7 @@ class CopilotSession {
       return void 0;
     }
     try {
-      const result = await handler(input, { sessionId: this.sessionId });
+      const result = await handler(normalized, { sessionId: this.sessionId });
       return result;
     } catch (_error) {
       return void 0;
@@ -722,7 +695,7 @@ class CopilotSession {
    *
    * @example
    * ```typescript
-   * const events = await session.getMessages();
+   * const events = await session.getEvents();
    * for (const event of events) {
    *   if (event.type === "assistant.message") {
    *     console.log("Assistant:", event.data.content);
@@ -730,7 +703,7 @@ class CopilotSession {
    * }
    * ```
    */
-  async getMessages() {
+  async getEvents() {
     const response = await this.connection.sendRequest("session.getMessages", {
       sessionId: this.sessionId
     });
@@ -770,18 +743,6 @@ class CopilotSession {
     this.exitPlanModeHandler = void 0;
     this.autoModeSwitchHandler = void 0;
   }
-  /**
-   * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
-   *
-   * Disconnects this session and releases all in-memory resources.
-   * Session data on disk is preserved for later resumption.
-   *
-   * @returns A promise that resolves when the session is disconnected
-   * @throws Error if the connection fails
-   */
-  async destroy() {
-    return this.disconnect();
-  }
   /** Enables `await using session = ...` syntax for automatic cleanup. */
   async [Symbol.asyncDispose]() {
     return this.disconnect();

package/dist/sessionFsProvider.d.ts

@@ -1,10 +1,35 @@
-import type { SessionFsHandler, SessionFsStatResult, SessionFsReaddirWithTypesEntry } from "./generated/rpc.js";
+import type { SessionFsHandler, SessionFsStatResult, SessionFsReaddirWithTypesEntry, SessionFsSqliteQueryResult as GeneratedSqliteQueryResult, SessionFsSqliteQueryType } from "./generated/rpc.js";
+export type { SessionFsSqliteQueryType };
 /**
  * File metadata returned by {@link SessionFsProvider.stat}.
  * Same shape as the generated {@link SessionFsStatResult} but without the
  * `error` field, since providers signal errors by throwing.
  */
 export type SessionFsFileInfo = Omit<SessionFsStatResult, "error">;
+/**
+ * Result of a SQLite query execution via {@link SessionFsSqliteProvider.query}.
+ * Same shape as the generated {@link GeneratedSqliteQueryResult} but without the
+ * `error` field, since providers signal errors by throwing.
+ */
+export type SessionFsSqliteQueryResult = Omit<GeneratedSqliteQueryResult, "error">;
+/**
+ * SQLite operations for the per-session database.
+ * Implementers provide query execution and existence checking.
+ */
+export interface SessionFsSqliteProvider {
+    /**
+     * Execute a SQLite query against the per-session database.
+     *
+     * @param queryType - How to execute: `"exec"` for DDL/multi-statement, `"query"` for SELECT, `"run"` for INSERT/UPDATE/DELETE.
+     * @param query - SQL query to execute.
+     * @param params - Optional named bind parameters.
+     */
+    query(queryType: SessionFsSqliteQueryType, query: string, params?: Record<string, string | number | null>): Promise<SessionFsSqliteQueryResult | undefined>;
+    /**
+     * Check whether the per-session database already exists, without creating it.
+     */
+    exists(): Promise<boolean>;
+}
 /**
  * Interface for session filesystem providers. Implementers use idiomatic
  * TypeScript patterns: throw on error, return values directly. Use
@@ -35,6 +60,8 @@ export interface SessionFsProvider {
     rm(path: string, recursive: boolean, force: boolean): Promise<void>;
     /** Renames/moves a file or directory. */
     rename(src: string, dest: string): Promise<void>;
+    /** Per-session SQLite database operations. Optional — omit if the provider does not support SQLite. */
+    sqlite?: SessionFsSqliteProvider;
 }
 /**
  * Wraps a {@link SessionFsProvider} into the {@link SessionFsHandler}

package/dist/sessionFsProvider.js

@@ -1,3 +1,15 @@
+function normalizeSqliteParams(params) {
+  if (!params) {
+    return void 0;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
 function createSessionFsAdapter(provider) {
   return {
     readFile: async ({ path }) => {
@@ -84,6 +96,28 @@ function createSessionFsAdapter(provider) {
       } catch (err) {
         return toSessionFsError(err);
       }
+    },
+    // Unlike the FS methods above, SQLite methods let errors propagate to the JSON-RPC layer
+    // rather than catching and mapping via toSessionFsError. The FS error mapping is specifically
+    // for translating Node.js errno codes (e.g., ENOENT) into SessionFsError, which isn't
+    // meaningful for SQL errors. Letting exceptions propagate preserves the original error
+    // message in the JSON-RPC error response.
+    sqliteQuery: async ({ queryType, query, params: bindParams }) => {
+      if (!provider.sqlite) {
+        throw new Error("SQLite is not supported by this provider");
+      }
+      const result = await provider.sqlite.query(
+        queryType,
+        query,
+        normalizeSqliteParams(bindParams)
+      );
+      return result ?? { rows: [], columns: [], rowsAffected: 0 };
+    },
+    sqliteExists: async () => {
+      if (!provider.sqlite) {
+        throw new Error("SQLite is not supported by this provider");
+      }
+      return { exists: await provider.sqlite.exists() };
     }
   };
 }