@google/adk 1.1.0 → 1.3.0

package/dist/types/integrations/agent_registry/agent_registry.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client, ClientFactory } from '@a2a-js/sdk/client';
+import { RemoteA2AAgent } from '../../a2a/a2a_remote_agent.js';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { AgentRegistrySingleMCPToolset } from './agent_registry_mcp_toolset.js';
+import { AgentInfo, ConnectionUriFilter, ConnectionUriResult, Endpoint, ListAgentsResponse, ListEndpointsResponse, ListMcpServersResponse, McpServer, ProtocolType } from './types.js';
+export * from './agent_registry_mcp_toolset.js';
+export * from './helpers.js';
+export * from './types.js';
+/**
+ * Client for interacting with the Google Cloud Agent Registry service.
+ *
+ * Unlike a standard REST client library, this class provides higher-level
+ * abstractions for ADK integration. It surfaces the agent registry service
+ * methods along with helper methods like `getMcpToolset` and
+ * `getRemoteA2AAgent` that automatically resolve connection details,
+ * manage OAuth authentication schemes, and handle GCP credentials to produce
+ * ready-to-use ADK components.
+ */
+export declare class AgentRegistry {
+    readonly projectId: string;
+    readonly location: string;
+    private readonly basePath;
+    private readonly headerProvider?;
+    private readonly auth;
+    constructor(options: {
+        projectId?: string | null;
+        location?: string | null;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    });
+    /**
+     * Resolves default Google Cloud credentials and returns standard headers.
+     * Automatically caches, fetches, and handles refreshing expired OAuth tokens.
+     * Injects the billing/quota project identifier `x-goog-user-project` if present.
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Helper function to execute HTTP GET requests against the Agent Registry API.
+     * Handles path resolution, search query params compilation, and auth headers fetching.
+     */
+    makeRequest<T = unknown>(path: string, params?: Record<string, string>): Promise<T>;
+    /**
+     * Parses connection interfaces list from registry metadata and returns the first match
+     * corresponding to requested protocol types and binding options.
+     */
+    getConnectionUri(resourceDetails: {
+        interfaces?: Array<{
+            url?: string;
+            protocolBinding?: string;
+        }>;
+        protocols?: Array<{
+            type?: ProtocolType;
+            protocolVersion?: string;
+            interfaces?: Array<{
+                url?: string;
+                protocolBinding?: string;
+            }>;
+        }>;
+    }, filters?: ConnectionUriFilter): ConnectionUriResult;
+    listMcpServers(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListMcpServersResponse>;
+    getMcpServer(name: string): Promise<McpServer>;
+    getMcpToolset(mcpServerName: string, options?: {
+        authScheme?: AuthScheme;
+        authCredential?: AuthCredential;
+        continueUri?: string;
+    }): Promise<AgentRegistrySingleMCPToolset>;
+    listEndpoints(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListEndpointsResponse>;
+    getEndpoint(name: string): Promise<Endpoint>;
+    getModelName(endpointName: string): Promise<string>;
+    listAgents(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListAgentsResponse>;
+    getAgentInfo(name: string): Promise<AgentInfo>;
+    getRemoteA2AAgent(agentName: string, options?: {
+        client?: Client;
+        clientFactory?: ClientFactory;
+    }): Promise<RemoteA2AAgent>;
+}

package/dist/types/integrations/agent_registry/agent_registry_mcp_toolset.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { BaseTool } from '../../tools/base_tool.js';
+import { BaseToolset, ToolPredicate } from '../../tools/base_toolset.js';
+import { StreamableHTTPConnectionParams } from '../../tools/mcp/mcp_session_manager.js';
+/**
+ * A specialized BaseToolset subclass designed to represent a single registered MCP server.
+ *
+ * Unlike a standard MCPToolset, this class:
+ * 1. Supports a dynamic `headerProvider` to fetch/refresh authorization and custom headers
+ *    immediately before establishing the MCP connection session.
+ * 2. Automatically injects the special `gcp.mcp.server.destination.id` telemetry metadata
+ *    identifier into all resolved tools' custom metadata, allowing downstream execute_tool
+ *    traces to be correctly attributed.
+ */
+export declare class AgentRegistrySingleMCPToolset extends BaseToolset {
+    readonly destinationResourceId?: string;
+    readonly connectionParams: StreamableHTTPConnectionParams;
+    readonly headerProvider?: (context?: ReadonlyContext) => Promise<Record<string, string>> | Record<string, string>;
+    readonly authScheme?: AuthScheme;
+    readonly authCredential?: AuthCredential;
+    /**
+     * @param options - Configuration for the MCP toolset.
+     * @param options.destinationResourceId - Telemetry identifier injected as
+     *   `gcp.mcp.server.destination.id` into each resolved tool's custom metadata.
+     * @param options.connectionParams - HTTP connection parameters for the MCP server.
+     * @param options.toolFilter - Optional predicate or list of tool names to include.
+     *   When omitted, all tools from the server are returned.
+     * @param options.prefix - Optional prefix prepended to each tool name (e.g. `myServer_toolName`).
+     * @param options.headerProvider - Optional async function called immediately before each
+     *   {@link getTools} invocation to supply or refresh request headers (e.g. GCP auth tokens).
+     * @param options.authScheme - Optional auth scheme forwarded to each resolved tool.
+     * @param options.authCredential - Optional credential forwarded to each resolved tool.
+     */
+    constructor(options: {
+        destinationResourceId?: string;
+        connectionParams: StreamableHTTPConnectionParams;
+        toolFilter?: ToolPredicate | string[];
+        prefix?: string;
+        headerProvider?: (context?: ReadonlyContext) => Promise<Record<string, string>> | Record<string, string>;
+        authScheme?: AuthScheme;
+        authCredential?: AuthCredential;
+    });
+    /**
+     * Connects to the underlying MCP server, retrieves tool definitions, prefixes
+     * tool names, and injects destination telemetry metadata into each tool.
+     *
+     * The `headerProvider`, if configured, is invoked immediately before the
+     * connection is established so that tokens are always fresh.
+     *
+     * @param context - Optional readonly agent context passed to the header provider.
+     * @returns The resolved and optionally filtered list of {@link MCPTool} instances.
+     */
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

package/dist/types/integrations/agent_registry/helpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function isGoogleApi(url: string): boolean;
+export declare function cleanName(name: string): string;

package/dist/types/integrations/agent_registry/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard, TransportProtocol } from '@a2a-js/sdk';
+export declare const AGENT_REGISTRY_BASE_URL = "https://agentregistry.googleapis.com/v1alpha";
+export declare const GCP_MCP_SERVER_DESTINATION_ID = "gcp.mcp.server.destination.id";
+export declare enum ProtocolType {
+    TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
+    A2A_AGENT = "A2A_AGENT",
+    CUSTOM = "CUSTOM"
+}
+export interface Interface {
+    url?: string;
+    protocolBinding?: string;
+}
+export interface Endpoint {
+    name?: string;
+    endpointId?: string;
+    displayName?: string;
+    description?: string;
+    interfaces?: Interface[];
+    createTime?: string;
+    updateTime?: string;
+    attributes?: Record<string, unknown>;
+}
+export interface GcpAuthProviderScheme {
+    type: 'gcpAuthProviderScheme';
+    name: string;
+    scopes?: string[];
+    continueUri?: string;
+}
+export interface McpServer {
+    name?: string;
+    displayName?: string;
+    mcpServerId?: string;
+    interfaces?: Interface[];
+    protocols?: Array<{
+        type?: ProtocolType;
+        protocolVersion?: string;
+        interfaces?: Interface[];
+    }>;
+    [key: string]: unknown;
+}
+export interface Binding {
+    target?: {
+        identifier?: string;
+    };
+    authProviderBinding?: {
+        authProvider?: string;
+    };
+}
+export interface ListBindingsResponse {
+    bindings?: Binding[];
+}
+export interface ListMcpServersResponse {
+    mcpServers?: Array<Record<string, unknown>>;
+    nextPageToken?: string;
+}
+export interface ListEndpointsResponse {
+    endpoints?: Array<Endpoint>;
+    nextPageToken?: string;
+}
+export interface ListAgentsResponse {
+    agents?: Array<Record<string, unknown>>;
+    nextPageToken?: string;
+}
+export interface AgentSkillMetadata {
+    id?: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    examples?: unknown[];
+}
+export interface AgentInfo {
+    displayName?: string;
+    description?: string;
+    version?: string;
+    card?: {
+        type?: string;
+        content?: AgentCard;
+    };
+    interfaces?: Interface[];
+    protocols?: Array<{
+        type?: ProtocolType;
+        protocolVersion?: string;
+        interfaces?: Interface[];
+    }>;
+    skills?: AgentSkillMetadata[];
+    [key: string]: unknown;
+}
+export interface ConnectionUriFilter {
+    protocolType?: ProtocolType;
+    protocolBinding?: string;
+}
+export interface ConnectionUriResult {
+    url?: string;
+    protocolVersion?: string;
+    protocolBinding?: TransportProtocol;
+}

package/dist/types/memory/vertex_ai_memory_bank_service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from '@google-cloud/vertexai';
+import { Event } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+import { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse } from './base_memory_service.js';
+import { MemoryEntry } from './memory_entry.js';
+export interface VertexAiMemoryBankServiceOptions {
+    projectId?: string;
+    location?: string;
+    agentEngineId: string;
+    expressModeApiKey?: string;
+    client?: Client;
+}
+/**
+ * Implementation of the BaseMemoryService using Vertex AI Memory Bank.
+ */
+export declare class VertexAiMemoryBankService implements BaseMemoryService {
+    private readonly projectId?;
+    private readonly location?;
+    private readonly agentEngineId;
+    private readonly expressModeApiKey?;
+    private readonly memories;
+    constructor(options: VertexAiMemoryBankServiceOptions);
+    addSessionToMemory(session: Session): Promise<void>;
+    /**
+     * Adds events to Vertex AI Memory Bank via memories.generate.
+     */
+    addEventsToMemory(request: {
+        appName: string;
+        userId: string;
+        events: Event[];
+        sessionId?: string;
+        customMetadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Adds explicit memory items using Vertex Memory Bank.
+     */
+    addMemory(request: {
+        appName: string;
+        userId: string;
+        memories: MemoryEntry[];
+        customMetadata?: Record<string, unknown>;
+    }): Promise<void>;
+    searchMemory(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
+    private addEventsToMemoryFromEvents;
+    private addMemoriesViaCreate;
+    private addMemoriesViaGenerateDirectMemoriesSource;
+}

package/dist/types/models/base_llm_connection.d.ts

@@ -38,6 +38,16 @@ export interface BaseLlmConnection {
      * @param blob The blob to send to the model.
      */
     sendRealtime(blob: Blob): Promise<void>;
+    /**
+     * Optionally signals the start of user activity (e.g. user begins speaking)
+     * for models that support manual activity boundaries.
+     */
+    sendActivityStart?(): Promise<void>;
+    /**
+     * Optionally signals the end of user activity (e.g. user finishes speaking)
+     * for models that support manual activity boundaries.
+     */
+    sendActivityEnd?(): Promise<void>;
     /**
      * Receives the model response using the llm server connection.
      *

package/dist/types/models/gemini_llm_connection.d.ts

@@ -1,15 +1,17 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Blob, Content, Session } from '@google/genai';
+import { Blob, Content, LiveServerMessage, Session } from '@google/genai';
 import { BaseLlmConnection } from './base_llm_connection.js';
 import { LlmResponse } from './llm_response.js';
 /** The Gemini model connection. */
 export declare class GeminiLlmConnection implements BaseLlmConnection {
     private readonly geminiSession;
-    constructor(geminiSession: Session);
+    private readonly modelVersion?;
+    private readonly messageQueue?;
+    constructor(geminiSession: Session, modelVersion?: string | undefined, messageQueue?: AsyncIterable<LiveServerMessage> | undefined);
     /**
      * Sends the conversation history to the gemini model.
      *
@@ -36,6 +38,14 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
      * @param blob The blob to send to the model.
      */
     sendRealtime(blob: Blob): Promise<void>;
+    /**
+     * Sends an activity start signal to the model.
+     */
+    sendActivityStart(): Promise<void>;
+    /**
+     * Sends an activity end signal to the model.
+     */
+    sendActivityEnd(): Promise<void>;
     /**
      * Builds a full text response.
      *
@@ -43,9 +53,10 @@ export declare class GeminiLlmConnection implements BaseLlmConnection {
      * partial.
      *
      * @param text The text to be included in the response.
+     * @param isThought Whether the text is a thought.
+     * @param groundingMetadata The grounding metadata to include.
      * @returns An LlmResponse containing the full text.
      */
-    private buildFullTextResponse;
     receive(): AsyncGenerator<LlmResponse, void, void>;
     /**
      * Closes the llm server connection.

package/dist/types/models/llm_response.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CitationMetadata, Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
+import { CitationMetadata, Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerGoAway, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
 /**
  * LLM response class that provides the first candidate response from the
  * model if available. Otherwise, returns error code and message.
@@ -64,6 +64,11 @@ export interface LlmResponse {
      * The session resumption update of the LlmResponse
      */
     liveSessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+    /**
+     * Server-side signal that the live connection will be closed soon. The
+     * caller should reconnect using the latest session resumption handle.
+     */
+    goAway?: LiveServerGoAway;
     /**
      * Audio transcription of user input.
      */
@@ -72,6 +77,10 @@ export interface LlmResponse {
      * Audio transcription of model output.
      */
     outputTranscription?: Transcription;
+    /** The model version used to generate the response. */
+    modelVersion?: string;
+    /** The session ID of the Live session. */
+    liveSessionId?: string;
 }
 /**
  * Creates an LlmResponse from a GenerateContentResponse.

package/dist/types/plugins/security_plugin.d.ts

@@ -17,18 +17,37 @@ export declare enum PolicyOutcome {
     CONFIRM = "CONFIRM",
     ALLOW = "ALLOW"
 }
+/** The result returned by a policy engine after evaluating a tool call. */
 export interface PolicyCheckResult {
+    /** The policy decision: `ALLOW`, `DENY`, or `CONFIRM`. */
     outcome: string;
+    /** Optional human-readable explanation of the decision. */
     reason?: string;
 }
+/** Context passed to a policy engine when evaluating a tool call. */
 export interface ToolCallPolicyContext {
+    /** The tool being invoked. */
     tool: BaseTool;
+    /** The arguments supplied to the tool call. */
     toolArgs: Record<string, unknown>;
 }
+/** Interface for policy engines that gate tool call execution. */
 export interface BasePolicyEngine {
+    /**
+     * Evaluates whether a tool call should be allowed, denied, or confirmed.
+     *
+     * @param context - The tool and its arguments to evaluate.
+     * @returns A promise resolving to the policy decision.
+     */
     evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
 }
+/** In-memory policy engine that permits all tool calls. Intended for prototyping. */
 export declare class InMemoryPolicyEngine implements BasePolicyEngine {
+    /**
+     * Always returns {@link PolicyOutcome.ALLOW} for every tool call.
+     *
+     * @returns A promise resolving to an ALLOW result.
+     */
     evaluate(): Promise<PolicyCheckResult>;
 }
 /**
@@ -36,9 +55,20 @@ export declare class InMemoryPolicyEngine implements BasePolicyEngine {
  */
 export declare class SecurityPlugin extends BasePlugin {
     private readonly policyEngine;
+    /**
+     * @param params - Optional configuration. Defaults to {@link InMemoryPolicyEngine}
+     *   when no policy engine is provided.
+     */
     constructor(params?: {
         policyEngine?: BasePolicyEngine;
     });
+    /**
+     * Intercepts tool calls, evaluating them against the policy engine before
+     * execution and handling confirmation flows for calls that require it.
+     *
+     * @returns A partial or error response object if the call is blocked or
+     *   awaiting confirmation, or `undefined` to allow execution to proceed.
+     */
     beforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: {

package/dist/types/runner/in_memory_runner.d.ts

@@ -6,8 +6,35 @@
 import { BaseAgent } from '../agents/base_agent.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { Runner } from './runner.js';
+/**
+ * A {@link Runner} pre-configured with in-memory services.
+ *
+ * Suitable for local development, testing, and prototyping. All session,
+ * artifact, and memory data is stored in-process and is not persisted between
+ * runs.
+ *
+ * Example:
+ * ```typescript
+ * const runner = new InMemoryRunner({agent: myAgent});
+ *
+ * for await (const event of runner.runEphemeral({
+ *   userId: 'user1',
+ *   newMessage: {parts: [{text: 'Hello'}]},
+ * })) {
+ *   console.log(event);
+ * }
+ * ```
+ */
 export declare class InMemoryRunner extends Runner {
-    constructor({ agent, appName, plugins, }: {
+    /**
+     * Creates a new InMemoryRunner instance.
+     *
+     * @param params The configuration for the runner.
+     * @param params.agent The root agent to run.
+     * @param params.appName The application name. Defaults to `'InMemoryRunner'`.
+     * @param params.plugins An optional list of plugins.
+     */
+    constructor(params: {
         agent: BaseAgent;
         appName?: string;
         plugins?: BasePlugin[];

package/dist/types/runner/runner.d.ts

@@ -25,10 +25,25 @@ export interface RunnerConfig {
      * The agent to run.
      */
     agent: BaseAgent;
+    /**
+     * An optional list of plugins to apply globally across all agents.
+     */
     plugins?: BasePlugin[];
+    /**
+     * An optional service for storing and retrieving artifacts.
+     */
     artifactService?: BaseArtifactService;
+    /**
+     * The service for managing sessions.
+     */
     sessionService: BaseSessionService;
+    /**
+     * An optional service for storing and querying agent memory.
+     */
     memoryService?: BaseMemoryService;
+    /**
+     * An optional service for managing authentication credentials.
+     */
     credentialService?: BaseCredentialService;
 }
 /**
@@ -42,6 +57,31 @@ declare const RUNNER_SIGNATURE_SYMBOL: unique symbol;
  * @returns True if the object is an instance of Runner, false otherwise.
  */
 export declare function isRunner(obj: unknown): obj is Runner;
+/**
+ * Orchestrates agent execution for a given application.
+ *
+ * The Runner manages the full lifecycle of an agent invocation: it loads the
+ * session, invokes plugin callbacks, runs the root agent, and yields the
+ * resulting events. Use {@link InMemoryRunner} for quick prototyping without
+ * external services.
+ *
+ * Example:
+ * ```typescript
+ * const runner = new Runner({
+ *   appName: 'my_app',
+ *   agent: myAgent,
+ *   sessionService: new InMemorySessionService(),
+ * });
+ *
+ * for await (const event of runner.runAsync({
+ *   userId: 'user1',
+ *   sessionId: 'session1',
+ *   newMessage: {parts: [{text: 'Hello'}]},
+ * })) {
+ *   console.log(event);
+ * }
+ * ```
+ */
 export declare class Runner {
     readonly [RUNNER_SIGNATURE_SYMBOL] = true;
     readonly appName: string;
@@ -51,6 +91,11 @@ export declare class Runner {
     readonly sessionService: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
+    /**
+     * Creates a new Runner instance.
+     *
+     * @param input The configuration for the runner.
+     */
     constructor(input: RunnerConfig);
     /**
      * Runs the agent with a new, ephemeral session.
@@ -66,6 +111,7 @@ export declare class Runner {
         newMessage: Content;
         stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
+        customMetadata?: Record<string, unknown>;
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Runs the agent with the given message, and returns an async generator of
@@ -85,6 +131,7 @@ export declare class Runner {
         stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
         abortSignal?: AbortSignal;
+        customMetadata?: Record<string, unknown>;
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Saves artifacts from the message parts and replaces the inline data with

package/dist/types/sessions/base_session_service.d.ts

@@ -48,6 +48,14 @@ export interface ListSessionsRequest {
     appName: string;
     /** The ID of the user. */
     userId: string;
+    /** Maximum number of sessions to return. */
+    limit?: number;
+    /** Zero-based index of the first session to return. Ignored if `page` is set. */
+    offset?: number;
+    /** 1-based page number. Requires `limit`. Takes precedence over `offset`. */
+    page?: number;
+    /** Sort direction by last update time. No ordering is applied if omitted. */
+    order?: 'asc' | 'desc';
 }
 /**
  * The parameters for `deleteSession`.
@@ -73,10 +81,20 @@ export interface AppendEventRequest {
  * The response of listing sessions.
  *
  * The events and states are not set within each Session object.
+ * When no pagination params were requested, `page` is 1, `limit` equals
+ * `totalItems`, and `totalPages` is 1 (or 0 when there are no sessions).
  */
 export interface ListSessionsResponse {
     /** A list of sessions. */
     sessions: Session[];
+    /** Current page number (1-based). */
+    page: number;
+    /** Page size used. Equals `totalItems` when no limit was requested. */
+    limit: number;
+    /** Total number of sessions matching the request. */
+    totalItems: number;
+    /** Total number of pages. */
+    totalPages: number;
 }
 /**
  * Base class for session services.
@@ -138,6 +156,10 @@ export declare abstract class BaseSessionService {
  * Removes temporary state delta keys from the event.
  */
 export declare function trimTempDeltaState(event: Event): Event;
+/**
+ * Removes temporary state keys from the state.
+ */
+export declare function trimTempState(state: Record<string, unknown>): Record<string, unknown>;
 /**
  * Merges app state, user state, and session state.
  *

package/dist/types/sessions/database_session_service.d.ts

@@ -26,7 +26,7 @@ export declare class DatabaseSessionService extends BaseSessionService {
     init(): Promise<void>;
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
     appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }

package/dist/types/sessions/db/schema.d.ts

@@ -7,6 +7,7 @@ import { PrimaryKey } from '@mikro-orm/core';
 import { Event } from '../../events/event.js';
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const SCHEMA_VERSION_1_JSON = "1";
+export declare const STORAGE_KEY_COLUMN_LENGTH = 191;
 export declare class StorageMetadata {
     key: string;
     value: string;

package/dist/types/sessions/in_memory_session_service.d.ts

@@ -24,7 +24,7 @@ export declare class InMemorySessionService extends BaseSessionService {
     private appState;
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
     appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }