@farukada/aws-langgraph-dynamodb-ts 1.0.0-rc.1 → 1.0.0

package/dist/esm/history/internal/append.js

@@ -0,0 +1,259 @@
+import { nowIso } from '../../shared/clock.js';
+import { PayloadLocation, collectS3Keys, } from '../../shared/codec/codec.js';
+import { cleanUpS3Orphans } from '../../shared/codec/s3/offloader.js';
+import { abortErrorFrom, isAbortError } from '../../shared/dynamodb/abort.js';
+import { batchWriteAll } from '../../shared/dynamodb/batch-write.js';
+import { conditionFailedAt, conditionalCheckFailure } from '../../shared/dynamodb/cancellation.js';
+import { readRow, settledVerdict, transactIdempotently, verdictFor, } from '../../shared/dynamodb/idempotent-write.js';
+import { SORT_KEY_ATTRIBUTE, rowKeyOf } from '../../shared/dynamodb/table-schema.js';
+import { failureLabel, hasErrorCode, toError, } from '../../shared/errors/base-error.js';
+import { refusedByService } from '../../shared/errors/classify.js';
+import { ErrorCode } from '../../shared/errors/error-code.js';
+import { compensationFailedError, retryBudgetMayStillLand, unsettledAppendError, } from '../../shared/errors/errors.js';
+import { absorbLoggerFailure } from '../../shared/logging/logger.js';
+import { truncateForLog } from '../../shared/logging/truncate.js';
+import { buildMessageRow } from './rows.js';
+import { buildSessionUpdate, deriveTitle, revertSessionCount, revertSessionCreation, } from './session.js';
+import { MESSAGE_APPEND_RETRY_MAX_ATTEMPTS } from './setup.js';
+const MAX_MESSAGES_PER_TRANSACTION = 99;
+const MAX_TRANSACTION_BYTES = 3_500_000;
+function keyOfFailedUpload(error) {
+    if (!hasErrorCode(error, ErrorCode.S3_OFFLOAD_FAILED))
+        return [];
+    const { operation, key } = error.context;
+    return operation === 'upload' && typeof key === 'string' ? [key] : [];
+}
+async function buildMessageRows(context, request) {
+    const { sessionId, signal } = request;
+    const ttlTimestamp = request.anchor?.ttlTimestamp;
+    const messageIds = request.messages.map(() => context.ulid());
+    const items = [];
+    try {
+        for (const [index, message] of request.messages.entries()) {
+            items.push(await buildMessageRow(context, { sessionId, messageId: messageIds[index], message, ttlTimestamp }, signal));
+        }
+    }
+    catch (error) {
+        if (context.offloader) {
+            await cleanUpS3Orphans(context.offloader, {
+                keys: [
+                    ...collectS3Keys(items.map((item) => item.message)),
+                    ...keyOfFailedUpload(error),
+                ],
+                operation: 'history.addMessages.encode',
+                logger: context.logger,
+            });
+        }
+        throw error;
+    }
+    return items;
+}
+export async function appendMessages(context, request) {
+    const items = await buildMessageRows(context, request);
+    const chunks = chunkBySize(items, MAX_MESSAGES_PER_TRANSACTION, MAX_TRANSACTION_BYTES);
+    await appendChunks(context, {
+        sessionId: request.sessionId,
+        chunks,
+        fields: {
+            now: nowIso(),
+            title: deriveTitle(request.messages),
+            ttlTimestamp: request.anchor?.ttlTimestamp,
+            forceTtlRefresh: request.anchor?.refresh,
+            restart: request.anchor?.expiredAnchor,
+        },
+        signal: request.signal,
+    });
+}
+function reportStep(context, report) {
+    absorbLoggerFailure(() => report(context.logger));
+}
+async function cleanBatchS3(context, chunks) {
+    if (!context.offloader)
+        return;
+    const descriptors = chunks.flat().map((item) => item.message);
+    await cleanUpS3Orphans(context.offloader, {
+        keys: collectS3Keys(descriptors),
+        operation: 'history.addMessages',
+        logger: context.logger,
+    });
+}
+async function rollbackCommitted(context, append, committed) {
+    const { sessionId } = append;
+    const { now, title } = append.fields;
+    const keys = committed.flatMap((chunk) => chunk.keys);
+    const total = committed.reduce((sum, chunk) => sum + chunk.count, 0);
+    if (keys.length === 0) {
+        await revertSessionCreation(context, sessionId, { total, createdAt: now, title });
+        return;
+    }
+    try {
+        await batchWriteAll(context.client, context.tableName, keys.map((Key) => ({ DeleteRequest: { Key } })), { retry: context.retry });
+    }
+    catch (error) {
+        const deleted = error.details
+            .succeededCount;
+        await revertSessionCount(context, sessionId, deleted, now);
+        throw error;
+    }
+    await revertSessionCreation(context, sessionId, { total, createdAt: now, title });
+}
+export async function compensate(context, append, failure) {
+    const { sessionId, chunks } = append;
+    const { committed, trigger, uncertain, unsettledBecause } = failure;
+    if (committed.length > 0) {
+        reportStep(context, (logger) => logger.warn('history.addMessages compensating committed chunks after a chunk failed', {
+            sessionId,
+            committedChunks: committed.length,
+        }));
+    }
+    const firstDead = committed.length + (uncertain ? 1 : 0);
+    await cleanBatchS3(context, chunks.slice(firstDead));
+    try {
+        await rollbackCommitted(context, append, committed);
+    }
+    catch (rollbackError) {
+        reportStep(context, (logger) => logger.error('history.addMessages rollback failed; messageCount may have drifted', {
+            sessionId,
+            committedChunks: committed.length,
+        }));
+        throw compensationFailedError(trigger, toError(rollbackError));
+    }
+    await cleanBatchS3(context, chunks.slice(0, committed.length));
+    if (!uncertain)
+        throw trigger;
+    reportStep(context, (logger) => logger.error('history.addMessages could not tell whether a failed chunk committed; messageCount may have drifted', {
+        sessionId,
+        committedChunks: committed.length,
+        reason: truncateForLog(failureLabel(unsettledBecause ?? trigger)),
+    }));
+    if (isAbortError(trigger))
+        throw trigger;
+    throw unsettledAppendError(trigger, unsettledBecause ?? trigger);
+}
+function chunkProbe(chunk) {
+    return {
+        key: rowKeyOf(chunk[0]),
+        kind: 'attribute',
+        attribute: SORT_KEY_ATTRIBUTE,
+        expected: chunk[0].SK,
+    };
+}
+async function settleFailedChunk(context, chunk, failure) {
+    const answeredRefusal = !isAbortError(failure) && !retryBudgetMayStillLand(failure) && refusedByService(failure);
+    if (answeredRefusal)
+        return { verdict: 'not-landed' };
+    const probe = chunkProbe(chunk);
+    let row;
+    try {
+        row = await readRow(context, probe);
+    }
+    catch (error) {
+        return { verdict: 'unverified', unsettledBecause: toError(error) };
+    }
+    const verdict = settledVerdict(verdictFor(probe, row), failure);
+    return verdict === 'unverified' ? { verdict, unsettledBecause: failure } : { verdict };
+}
+async function commitChunk(context, append, chunk, position) {
+    const fields = { ...append.fields, sessionId: append.sessionId, count: chunk.length };
+    try {
+        await writeMessageChunk(context, chunk, position === 0 ? fields : { ...fields, restart: undefined }, { signal: append.signal });
+        return undefined;
+    }
+    catch (error) {
+        return toError(error);
+    }
+}
+function asCommitted(chunk) {
+    return { keys: chunk.map((item) => rowKeyOf(item)), count: chunk.length };
+}
+export async function appendChunks(context, append) {
+    const committed = [];
+    for (const [position, chunk] of append.chunks.entries()) {
+        if (append.signal?.aborted) {
+            await compensate(context, append, {
+                committed,
+                trigger: abortErrorFrom(append.signal),
+                uncertain: false,
+            });
+        }
+        const failure = await commitChunk(context, append, chunk, position);
+        if (!failure) {
+            committed.push(asCommitted(chunk));
+            continue;
+        }
+        const settled = await settleFailedChunk(context, chunk, failure);
+        if (settled.verdict === 'landed')
+            committed.push(asCommitted(chunk));
+        if (settled.verdict === 'landed' && !isAbortError(failure))
+            continue;
+        await compensate(context, append, {
+            committed,
+            trigger: failure,
+            uncertain: settled.verdict === 'unverified',
+            unsettledBecause: settled.unsettledBecause,
+        });
+    }
+}
+function isTtlConditionLoss(error) {
+    return conditionFailedAt(error, 0) && conditionalCheckFailure(error) !== undefined;
+}
+async function attempt(context, items, fields, retry) {
+    await transactIdempotently(context, [
+        buildSessionUpdate(context.tableName, fields),
+        ...items.map((item) => ({ Put: { TableName: context.tableName, Item: item } })),
+    ], { signal: retry.signal, rng: retry.rng, minAttempts: MESSAGE_APPEND_RETRY_MAX_ATTEMPTS });
+}
+export async function writeMessageChunk(context, items, fields, retry = {}) {
+    const withIndex = { ...fields, indexShards: context.indexShards, writeId: context.ulid() };
+    try {
+        await attempt(context, items, withIndex, retry);
+    }
+    catch (error) {
+        const pinned = fields.forceTtlRefresh || fields.restart !== undefined;
+        if (pinned && isTtlConditionLoss(error)) {
+            await attempt(context, items, { ...withIndex, forceTtlRefresh: false, restart: undefined }, retry);
+            return;
+        }
+        throw error;
+    }
+}
+const ROW_OVERHEAD_BYTES = 256;
+function utf8Bytes(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+function descriptorBytes(descriptor) {
+    const body = descriptor.location === PayloadLocation.INLINE
+        ? descriptor.bytes.length
+        : utf8Bytes(descriptor.s3Key);
+    return body + utf8Bytes(descriptor.serdeType);
+}
+export function estimateRowBytes(item) {
+    return (utf8Bytes(item.PK) +
+        utf8Bytes(item.SK) +
+        utf8Bytes(item.sessionId) +
+        descriptorBytes(item.message) +
+        ROW_OVERHEAD_BYTES);
+}
+function shouldFlush(chunk, next, limits) {
+    if (chunk.count === 0)
+        return false;
+    return chunk.count >= limits.maxItems || chunk.bytes + next > limits.maxBytes;
+}
+export function chunkBySize(items, maxItems, maxBytes) {
+    const chunks = [];
+    let current = [];
+    let currentBytes = 0;
+    for (const item of items) {
+        const size = estimateRowBytes(item);
+        if (shouldFlush({ count: current.length, bytes: currentBytes }, size, { maxItems, maxBytes })) {
+            chunks.push(current);
+            current = [];
+            currentBytes = 0;
+        }
+        current.push(item);
+        currentBytes += size;
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}

package/dist/esm/history/internal/message-read.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Hides how a session's message key space is read.
+ *
+ * A read admits only rows this package wrote as a message of this session,
+ * refusing any other row in the key space rather than skipping it, treats an
+ * expired row as absent however long the sweep lags, walks newest-first when
+ * it wants the latest few and restores chronological order, and counts the
+ * rows the same way it reads them, so a repaired count is the number a read
+ * returns.
+ */
+import type { ParsedWindow, SessionId } from './parse.js';
+import { type MessageRow } from './rows.js';
+import type { HistoryContext } from './setup.js';
+/**
+ * Read the live message items a window selects, in chronological order.
+ *
+ * Without `limit` the query walks the session oldest-first. With it the query
+ * walks newest-first with a matching page cap and stops as soon as `limit`
+ * live items are in hand — rows past their TTL are skipped here, so a page can
+ * come back short and the walk simply continues — and the tail is then
+ * reversed back into chronological order. `before` becomes an exclusive upper
+ * sort-key bound: the message prefix plus the ULID time characters of that
+ * instant, which every message id from that millisecond onwards sorts after.
+ *
+ * Accepts: `window.limit` — absent asks for the whole session, which is what
+ * `getMessages()` with no arguments means; otherwise at least 1, which is why
+ * no zero case is handled below. `parseMessageWindow` refuses `0` for its
+ * own reason, and that refusal is also what keeps `Limit: 0` — which DynamoDB
+ * rejects outright with a raw `ValidationException` — out of the query built
+ * here. `window.before` — already parsed as a real date. `signal` — aborts
+ * between pages.
+ *
+ * Returns: the live messages in chronological order, oldest first, whichever
+ * direction the query walked.
+ *
+ * Throws: `FORMAT_UNSUPPORTED` for a row a newer version wrote — checked before
+ * the row's ttl, so the answer does not depend on the reading machine's clock;
+ * `VALIDATION` naming `message` for a row in this session's message key
+ * space that this adapter did not write, checked before the ttl for the same
+ * reason; `ABORTED`; whatever the query throws.
+ *
+ * Guarantees: strongly consistent, so the turn just appended is visible to the
+ * very next read. An unlimited window is deliberately uncapped — silently
+ * truncating a conversation is worse than a slow read, and a caller that wants
+ * a bound passes `limit` — so past {@link LIST_SCAN_WARN_THRESHOLD} messages
+ * the read still succeeds and an operator is told the session is unusually
+ * large.
+ */
+export declare function readWindow(context: HistoryContext, sessionId: SessionId, window: ParsedWindow, signal?: AbortSignal): Promise<MessageRow[]>;
+/**
+ * The number of message rows a session holds, counted the way the read path
+ * counts them.
+ *
+ * Only rows `getMessages` would return are counted: an expired message that
+ * DynamoDB's TTL sweep has not yet removed is invisible to every reader, so
+ * counting it would "repair" `messageCount` to a number nobody ever sees. The
+ * count is therefore a definition, not an implementation detail — it is what
+ * makes the repaired value agree with what the session returns. For the same
+ * reason a message a newer release wrote, and a row in the message key space
+ * that this adapter did not write, are both refused rather than counted:
+ * `getMessages` refuses them.
+ *
+ * Accepts: `sessionId` — validated by the caller. `signal` — aborts the reads.
+ *
+ * Returns: how many messages a reader would actually see right now.
+ *
+ * Throws: `FORMAT_UNSUPPORTED` for a message row a newer release wrote, checked
+ * before the row's ttl as `getMessages` checks it; `VALIDATION` naming
+ * `message` for a row in the message key space that is not one of this
+ * adapter's, which `getMessages` refuses too; whatever the query throws
+ * after retries; `ABORTED`.
+ *
+ * Guarantees: each row comes back projected to its identity, its format
+ * version and its ttl, so no message payload is transferred however large the
+ * session is — the descriptor is projected by the one nested path
+ * `message.location` that every descriptor this package has written carries,
+ * which proves the attribute is there and a map without reading the bytes it
+ * holds. Every check runs here rather than in a filter, because a filter would
+ * drop an expired row before its version could be checked. The pages are
+ * walked by the shared paginator with both of its caps lifted: a partial count
+ * is not a repair, it is a new and wrong number, so the count either completes
+ * or fails.
+ */
+export declare function countLiveMessages(context: HistoryContext, sessionId: SessionId, signal?: AbortSignal): Promise<number>;

package/dist/esm/history/internal/message-read.js

@@ -0,0 +1,89 @@
+import { nowSeconds } from '../../shared/clock.js';
+import { LIST_SCAN_WARN_THRESHOLD, paginateQuery } from '../../shared/dynamodb/paginate.js';
+import { retryFor } from '../../shared/dynamodb/retry.js';
+import { isExpiredRow, assertReadableRow } from '../../shared/dynamodb/table-schema.js';
+import { validationError } from '../../shared/errors/errors.js';
+import { truncateForLog } from '../../shared/logging/truncate.js';
+import { ulidTimePrefix } from '../../shared/ulid.js';
+import { messageQuery, messageSortKey, parseMessageRow } from './rows.js';
+function parseSessionMessageRow(context, sessionId, raw) {
+    assertReadableRow(raw, 'message');
+    const item = parseMessageRow(raw);
+    if (item)
+        return item;
+    context.logger.warn('getMessages: refused a row that is not a chat message item', {
+        sessionId,
+        sortKey: truncateForLog(raw.SK),
+    });
+    throw validationError('a row in the message key space of this session is not a chat message item this package ' +
+        'wrote: its `sessionId` or `message` attribute is absent, is of the wrong type, or names ' +
+        'another session. The `warn` logged alongside this names the row', 'message');
+}
+export async function readWindow(context, sessionId, window, signal) {
+    const now = nowSeconds();
+    const limit = window.limit ?? Number.POSITIVE_INFINITY;
+    const items = [];
+    for await (const raw of paginateQuery({
+        retry: retryFor(context, signal),
+        signal,
+        client: context.client,
+        params: messageQuery(context.tableName, sessionId, {
+            consistent: true,
+            descending: window.limit !== undefined,
+            limit: window.limit,
+            beforeSortKey: window.before && messageSortKey(ulidTimePrefix(window.before.getTime())),
+        }),
+        maxItems: Number.POSITIVE_INFINITY,
+        maxIterations: Number.POSITIVE_INFINITY,
+    })) {
+        const item = parseSessionMessageRow(context, sessionId, raw);
+        if (isExpiredRow(item, now))
+            continue;
+        items.push(item);
+        if (items.length >= limit)
+            break;
+    }
+    if (items.length >= LIST_SCAN_WARN_THRESHOLD) {
+        context.logger.warn('getMessages: a session holds very many messages; the read is complete but slow. Pass a ' +
+            '`limit` to read only the newest turns', { sessionId, messages: items.length });
+    }
+    return window.limit === undefined ? items : items.reverse();
+}
+function parseCountableRow(raw, sessionId) {
+    assertReadableRow(raw, 'message');
+    const item = parseMessageRow(raw);
+    if (item)
+        return item;
+    throw validationError(`session "${sessionId}" holds a row in its message key space that is not a chat message ` +
+        'item this package wrote, so its messages cannot be counted: a read of the session ' +
+        'reports the same row and names it. Remove or repair the row, then reconcile again', 'message');
+}
+export async function countLiveMessages(context, sessionId, signal) {
+    const now = nowSeconds();
+    const query = messageQuery(context.tableName, sessionId, { consistent: true });
+    let total = 0;
+    for await (const raw of paginateQuery({
+        retry: retryFor(context, signal),
+        signal,
+        client: context.client,
+        params: {
+            ...query,
+            ProjectionExpression: '#pk, #sid, #msg.#loc, #v, #ttl',
+            ExpressionAttributeNames: {
+                ...query.ExpressionAttributeNames,
+                '#sid': 'sessionId',
+                '#msg': 'message',
+                '#loc': 'location',
+                '#v': 'v',
+                '#ttl': 'ttl',
+            },
+        },
+        maxItems: Number.POSITIVE_INFINITY,
+        maxIterations: Number.POSITIVE_INFINITY,
+    })) {
+        const row = parseCountableRow(raw, sessionId);
+        if (!isExpiredRow(row, now))
+            total += 1;
+    }
+    return total;
+}

package/dist/esm/history/internal/parse.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Hides the rules chat-history input must meet before anything reads it.
+ *
+ * A session id, an append's messages, a read window and the listing options
+ * are each parsed once into a type only this module can build (record 21), so
+ * an action that holds one never checks it again. Which messages may be
+ * stored is decided by the read side's own rebuild, so write and read agree
+ * by construction, and which instants a `before` may name follows from the
+ * range a message id can express.
+ */
+import { type BaseMessage, type StoredMessage } from '@langchain/core/messages';
+import { type PageLimit } from '../../shared/validation/primitives.js';
+import type { GetMessagesOptions, ListSessionsOptions, MessageWindow } from '../types.js';
+declare const sessionIdBrand: unique symbol;
+declare const storableMessagesBrand: unique symbol;
+declare const parsedWindowBrand: unique symbol;
+/**
+ * A session id checked as the partition key it becomes. {@link parseSessionId}
+ * is the only way to obtain one, so an internal function that asks for a
+ * `SessionId` cannot be handed one nobody checked, and does not check it again.
+ * Each of the four history actions that take one — add, clear, get and
+ * reconcile — parses it on every call, and the session adapter parses the id
+ * it is bound to when it is built. The brand is phantom: at run time it is the
+ * caller's string.
+ */
+export type SessionId = string & {
+    readonly [sessionIdBrand]: true;
+};
+/**
+ * Messages in their stored form, each one proven to rebuild on the read side.
+ * Built only by {@link parseStoredMessages}; the array is the one
+ * {@link parseMessages} made, which no caller holds.
+ */
+export type StorableMessages = StoredMessage[] & {
+    readonly [storableMessagesBrand]: true;
+};
+/**
+ * A conversation window checked against the page rule and the range a message
+ * id can express, holding only the keys the caller gave. Built only by
+ * {@link parseMessageWindow}; its `before` is a copy, so a caller moving its own
+ * `Date` afterwards moves nothing this package reads.
+ */
+export type ParsedWindow = {
+    readonly limit?: PageLimit;
+    readonly before?: Date;
+} & {
+    readonly [parsedWindowBrand]: true;
+};
+/**
+ * Parse a session id.
+ *
+ * Accepts: `value` — anything; a session id reaches the partition key, so it is
+ * held to every identifier rule at {@link MAX_PARTITION_ID_BYTES}.
+ *
+ * Returns: `value` as a {@link SessionId}.
+ *
+ * Throws: `VALIDATION` naming `sessionId`.
+ */
+export declare function parseSessionId(value: unknown): SessionId;
+/**
+ * Parse stored messages: prove each one rebuilds on the read side.
+ *
+ * Accepts: `stored` — the stored form of one call's messages. The check *is*
+ * the read side's own rebuild (`mapStoredMessagesToChatMessages`), so write and
+ * read agree by construction rather than by two lists of types kept in step by
+ * hand.
+ *
+ * Returns: `stored`, as {@link StorableMessages}.
+ *
+ * Throws: `VALIDATION` naming `messages`, carrying the offending index and
+ * type. The type comes off the caller's own object and nothing length-checked
+ * it, so the message names it bounded by {@link truncateForLog}, and so is
+ * what LangChain says about it — that text renders the same unchecked value
+ * into itself, so bounding only the type bounds nothing. The two take
+ * different caps because they are different things: the type is an identifier,
+ * while what LangChain threw is prose, cut once by `redactedMessage` and not
+ * again here. `context` still names `messages`, which is what a caller
+ * branches on. A `RemoveMessage`, or a tool, function or generic message
+ * missing its required field, is refused here instead of being persisted and
+ * then skipped or thrown by `getMessages`. A hole in a sparse array is refused
+ * as missing, naming its index: the array is walked by index, where
+ * `Array.prototype.forEach` would skip the hole and let it through.
+ */
+export declare function parseStoredMessages(stored: StoredMessage[]): StorableMessages;
+/**
+ * Parse the messages of one append, in two passes: to the stored form, then
+ * proof that each rebuilds.
+ *
+ * Accepts: `messages` — declared `BaseMessage[]`; a non-array is refused, and
+ * so is an entry LangChain cannot serialize.
+ *
+ * Returns: a fresh array of stored messages, as {@link StorableMessages}.
+ *
+ * Throws: `VALIDATION` naming `messages`, with the offending index for an
+ * entry.
+ */
+export declare function parseMessages(messages: BaseMessage[]): StorableMessages;
+/**
+ * Parse a conversation window.
+ *
+ * Accepts: `window.limit` — an integer from 1 to the page ceiling; the only
+ * floor of 1 in the package, because a window feeds a model, and an empty
+ * conversation is not a visibly empty answer but an invented one.
+ * `window.before` — a valid `Date` inside the range a message id can express.
+ *
+ * Returns: a fresh window holding only the keys the caller gave, as a
+ * {@link ParsedWindow}.
+ *
+ * Throws: `VALIDATION` naming `limit` or `before`.
+ */
+export declare function parseMessageWindow(window: MessageWindow): ParsedWindow;
+/** The arguments of `getMessages`, parsed. */
+export interface GetMessagesRequest {
+    readonly sessionId: SessionId;
+    readonly window: ParsedWindow;
+    readonly signal: AbortSignal | undefined;
+}
+/**
+ * Parse the arguments of `getMessages`.
+ *
+ * Accepts: `sessionId` — as {@link parseSessionId}. `options` — an object with
+ * only `limit`, `before` and `signal`; the window as {@link parseMessageWindow}.
+ *
+ * Returns: the request the read works from.
+ *
+ * Throws: `VALIDATION`, in this order: `options.<key>`, `signal`, `sessionId`,
+ * `limit`, `before`.
+ */
+export declare function parseGetMessagesRequest(sessionId: string, options: GetMessagesOptions): GetMessagesRequest;
+/** The options of `listSessions`, parsed. */
+export interface ListSessionsRequest {
+    readonly limit: PageLimit | undefined;
+    readonly maxItems: number | undefined;
+    readonly maxIterations: number | undefined;
+    readonly cursor: string | undefined;
+    readonly signal: AbortSignal | undefined;
+}
+/**
+ * Parse the options of `listSessions`.
+ *
+ * Accepts: `options` — only `limit`, `cursor`, `maxIterations`, `maxItems` and
+ * `signal`. `limit` — 0 to the page ceiling; `0` is answered with an empty page.
+ * `maxItems`, `maxIterations` — an integer of at least 1, or `Infinity`.
+ * `cursor` — a string, and only with `indexName`. `indexName` — the adapter's
+ * configured recency index, if any.
+ *
+ * Returns: the request the listing works from.
+ *
+ * Throws: `VALIDATION`, in this order: `options.<key>`, `signal`, `limit`,
+ * `maxItems`, `maxIterations`, `cursor`.
+ */
+export declare function parseListSessionsRequest(options: ListSessionsOptions, indexName: string | undefined): ListSessionsRequest;
+export {};