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

package/dist/history/actions/list-sessions.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listSessions = listSessions;
-const clock_1 = require("../../shared/clock");
-const expiry_1 = require("../../shared/dynamodb/expiry");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const scan_1 = require("../../shared/dynamodb/scan");
-const keys_1 = require("../internal/keys");
-/**
- * List all sessions as metadata summaries, newest-updated first. The scan is
- * filtered to session items so the adapter works on a table shared with the
- * checkpointer/store; foreign rows are also skipped defensively, and rows past
- * their TTL are filtered out exactly as `getMessages` filters expired messages.
- */
-async function listSessions(context, options) {
-    const sessions = [];
-    const nowSeconds = (0, clock_1.nowSeconds)();
-    for await (const raw of (0, scan_1.paginateScan)({
-        retry: (0, retry_policy_1.retryFor)(context, options?.signal),
-        signal: options?.signal,
-        client: context.client,
-        params: {
-            TableName: context.tableName,
-            FilterExpression: '#sk = :session',
-            ExpressionAttributeNames: { '#sk': 'SK' },
-            ExpressionAttributeValues: { ':session': keys_1.SESSION_SORT_KEY },
-        },
-        maxIterations: options?.maxIterations,
-        maxItems: options?.maxItems,
-    })) {
-        const item = raw;
-        if (item.SK !== keys_1.SESSION_SORT_KEY || typeof item.sessionId !== 'string')
-            continue;
-        if ((0, expiry_1.isExpiredRow)(item, nowSeconds))
-            continue;
-        sessions.push({
-            sessionId: item.sessionId,
-            title: item.title,
-            messageCount: item.messageCount,
-            createdAt: item.createdAt,
-            updatedAt: item.updatedAt,
-            expiresAt: item.ttl === undefined ? undefined : new Date(item.ttl * 1000).toISOString(),
-        });
-    }
-    /**
-     * Ordinal, not `localeCompare`: these are ISO-8601 timestamps, whose
-     * byte order already is their chronological order. Locale-aware collation
-     * applies rules (case folding, punctuation weighting) that have no meaning
-     * here and are not guaranteed to agree with it in every locale.
-     */
-    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
-    return sessions;
-}

package/dist/history/actions/reconcile-count.d.ts

@@ -1,12 +0,0 @@
-import type { HistoryContext } from '../internal/setup';
-/**
- * Recompute `messageCount` from the authoritative number of stored message items
- * and write it back, repairing any drift. A repair tool: the append path keeps
- * the count consistent transactionally, so this is only needed after external
- * corruption. Run it when the session is quiescent — it `SET`s the count, so a
- * concurrent append's increment could be clobbered. Requires the session to
- * already exist; reconciling a nonexistent session throws {@link ConflictError}
- * rather than creating a permanent, TTL-less metadata-only row. Returns the
- * reconciled count.
- */
-export declare function reconcileMessageCount(context: HistoryContext, sessionId: string, signal?: AbortSignal): Promise<number>;

package/dist/history/actions/reconcile-count.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reconcileMessageCount = reconcileMessageCount;
-const clock_1 = require("../../shared/clock");
-const retry_1 = require("../../shared/dynamodb/retry");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const errors_1 = require("../../shared/errors/errors");
-const keys_1 = require("../internal/keys");
-const query_1 = require("../internal/query");
-const validation_1 = require("../internal/validation");
-/**
- * Count only the rows `getMessages` would return: an expired message that
- * DynamoDB's TTL sweep has not yet removed is invisible to the read path, so
- * counting it would "repair" `messageCount` to a number no reader ever sees.
- */
-async function countMessages(context, sessionId, signal) {
-    const query = (0, query_1.messageQuery)(context.tableName, sessionId);
-    const base = {
-        ...query,
-        Select: 'COUNT',
-        FilterExpression: 'attribute_not_exists(#ttl) OR #ttl > :now',
-        ExpressionAttributeNames: { ...query.ExpressionAttributeNames, '#ttl': 'ttl' },
-        ExpressionAttributeValues: { ...query.ExpressionAttributeValues, ':now': (0, clock_1.nowSeconds)() },
-    };
-    let total = 0;
-    let startKey;
-    do {
-        const page = await (0, retry_1.withDynamoDBRetry)(() => context.client.query({ ...base, ExclusiveStartKey: startKey }), (0, retry_policy_1.retryFor)(context, signal));
-        total += page.Count ?? 0;
-        startKey = page.LastEvaluatedKey;
-    } while (startKey);
-    return total;
-}
-/**
- * Recompute `messageCount` from the authoritative number of stored message items
- * and write it back, repairing any drift. A repair tool: the append path keeps
- * the count consistent transactionally, so this is only needed after external
- * corruption. Run it when the session is quiescent — it `SET`s the count, so a
- * concurrent append's increment could be clobbered. Requires the session to
- * already exist; reconciling a nonexistent session throws {@link ConflictError}
- * rather than creating a permanent, TTL-less metadata-only row. Returns the
- * reconciled count.
- */
-async function reconcileMessageCount(context, sessionId, signal) {
-    (0, validation_1.validateSessionId)(sessionId);
-    const count = await countMessages(context, sessionId, signal);
-    try {
-        await (0, retry_1.withDynamoDBRetry)(() => context.client.update({
-            TableName: context.tableName,
-            Key: { PK: (0, keys_1.sessionPartition)(sessionId), SK: keys_1.SESSION_SORT_KEY },
-            UpdateExpression: 'SET #count = :count',
-            ExpressionAttributeNames: { '#count': 'messageCount' },
-            ExpressionAttributeValues: { ':count': count },
-            ConditionExpression: 'attribute_exists(PK)',
-        }), (0, retry_policy_1.retryFor)(context, signal));
-    }
-    catch (error) {
-        if (error.name === 'ConditionalCheckFailedException') {
-            throw new errors_1.ConflictError(`Cannot reconcile messageCount: session "${sessionId}" does not exist`, error);
-        }
-        throw error;
-    }
-    return count;
-}

package/dist/history/chat-message-history.d.ts

@@ -1,73 +0,0 @@
-import type { BaseMessage } from '@langchain/core/messages';
-import type { CancelOptions } from '../shared/options';
-import { type AdapterWindow, DynamoDBSessionChatMessageHistory } from './session-adapter';
-import type { DynamoDBChatMessageHistoryOptions, GetMessagesOptions, ListSessionsOptions, SessionMetadata } from './types';
-/**
- * DynamoDB-backed multi-session chat history. Each message is its own item
- * (ordered by a monotonic ULID, compressed / S3-offloaded as needed) alongside a
- * per-session metadata item; every message in a session shares one uniform TTL.
- * Appends are O(1) and lock-free. Use {@link forSession} to get a single-session
- * LangChain adapter. Every public method is the library's error boundary — a
- * raw AWS SDK error escaping an action surfaces as an `UpstreamError`.
- */
-export declare class DynamoDBChatMessageHistory {
-    private readonly context;
-    private readonly ownsClient;
-    private readonly ddbClient;
-    constructor(options: DynamoDBChatMessageHistoryOptions);
-    /**
-     * Get a session's messages in chronological order: the whole session by
-     * default, or a window of it — `{ limit }` returns only the newest `limit`
-     * messages, `{ before }` only those appended before that instant — so a
-     * long-lived session can be read a page at a time instead of whole.
-     * @remarks Strongly consistent; one query page plus one S3 download per offloaded message.
-     * @throws ValidationError for a malformed session id or window; UpstreamError; AbortError; and, under `onCorruptMessage: 'throw'`, the decode error of a corrupt row.
-     */
-    getMessages(sessionId: string, options?: GetMessagesOptions): Promise<BaseMessage[]>;
-    /**
-     * Append messages to a session in one transaction per chunk of up to 99
-     * messages, keeping the session's `messageCount` exact. Lock-free and safe
-     * under concurrent appends to one session; every message shares the
-     * session's TTL when one is configured.
-     * @throws ValidationError for a message that could never be read back; CompensationFailedError when a later chunk fails and the rollback fails too; RetryExhaustedError after 18 contended attempts; UpstreamError; AbortError.
-     */
-    addMessages(sessionId: string, messages: BaseMessage[], options?: CancelOptions): Promise<void>;
-    /** Append one message; see {@link addMessages}. */
-    addMessage(sessionId: string, message: BaseMessage, options?: CancelOptions): Promise<void>;
-    /**
-     * Delete a session's messages, metadata and offloaded objects. Single pass:
-     * call it when the session is quiescent.
-     * @throws BatchWriteAllIncompleteError when a delete batch does not fully drain; UpstreamError; AbortError.
-     */
-    clear(sessionId: string, options?: CancelOptions): Promise<void>;
-    /**
-     * List every session as a metadata summary, most recently updated first.
-     * A table scan: cross-tenant by construction and bounded by `maxItems` /
-     * `maxIterations`.
-     * @throws ResultTruncatedError past either cap; UpstreamError; AbortError.
-     */
-    listSessions(options?: ListSessionsOptions): Promise<SessionMetadata[]>;
-    /**
-     * Recompute and repair a session's `messageCount` from the stored messages.
-     * A maintenance tool for external corruption; run it when the session is idle.
-     * @throws ConflictError when the session does not exist or changed while counting; UpstreamError; AbortError.
-     */
-    reconcileMessageCount(sessionId: string, options?: CancelOptions): Promise<number>;
-    /**
-     * Get a single-session LangChain adapter for `sessionId`. `{ limit }` bounds
-     * what the adapter feeds the chain to the newest `limit` messages.
-     */
-    forSession(sessionId: string, window?: AdapterWindow): DynamoDBSessionChatMessageHistory;
-    /** Release owned resources (the underlying client and any S3 client). */
-    destroy(): void;
-    /**
-     * Provision an S3 lifecycle expiration rule matching the configured TTL, so
-     * offloaded objects don't outlive their DynamoDB item forever. No-ops when
-     * S3 offload or TTL isn't configured; throws when the bucket cannot be read
-     * or written. Requires the `s3:GetLifecycleConfiguration` /
-     * `s3:PutLifecycleConfiguration` bucket-level permissions (broader than the
-     * object-level CRUD the rest of S3 offload needs) — call this once during
-     * deployment/provisioning, not per-request.
-     */
-    ensureS3LifecycleRule(): Promise<void>;
-}

package/dist/history/chat-message-history.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBChatMessageHistory = void 0;
-const boundary_1 = require("../shared/errors/boundary");
-const ttl_1 = require("../shared/validation/ttl");
-const add_messages_1 = require("./actions/add-messages");
-const clear_1 = require("./actions/clear");
-const get_messages_1 = require("./actions/get-messages");
-const list_sessions_1 = require("./actions/list-sessions");
-const reconcile_count_1 = require("./actions/reconcile-count");
-const setup_1 = require("./internal/setup");
-const session_adapter_1 = require("./session-adapter");
-/**
- * DynamoDB-backed multi-session chat history. Each message is its own item
- * (ordered by a monotonic ULID, compressed / S3-offloaded as needed) alongside a
- * per-session metadata item; every message in a session shares one uniform TTL.
- * Appends are O(1) and lock-free. Use {@link forSession} to get a single-session
- * LangChain adapter. Every public method is the library's error boundary — a
- * raw AWS SDK error escaping an action surfaces as an `UpstreamError`.
- */
-class DynamoDBChatMessageHistory {
-    context;
-    ownsClient;
-    ddbClient;
-    constructor(options) {
-        const setup = (0, setup_1.setUpHistory)(options);
-        this.context = setup.context;
-        this.ownsClient = setup.ownsClient;
-        this.ddbClient = setup.ddbClient;
-    }
-    /**
-     * Get a session's messages in chronological order: the whole session by
-     * default, or a window of it — `{ limit }` returns only the newest `limit`
-     * messages, `{ before }` only those appended before that instant — so a
-     * long-lived session can be read a page at a time instead of whole.
-     * @remarks Strongly consistent; one query page plus one S3 download per offloaded message.
-     * @throws ValidationError for a malformed session id or window; UpstreamError; AbortError; and, under `onCorruptMessage: 'throw'`, the decode error of a corrupt row.
-     */
-    getMessages(sessionId, options) {
-        return (0, boundary_1.guardPublic)('history.getMessages', () => (0, get_messages_1.getMessages)(this.context, sessionId, options));
-    }
-    /**
-     * Append messages to a session in one transaction per chunk of up to 99
-     * messages, keeping the session's `messageCount` exact. Lock-free and safe
-     * under concurrent appends to one session; every message shares the
-     * session's TTL when one is configured.
-     * @throws ValidationError for a message that could never be read back; CompensationFailedError when a later chunk fails and the rollback fails too; RetryExhaustedError after 18 contended attempts; UpstreamError; AbortError.
-     */
-    addMessages(sessionId, messages, options) {
-        return (0, boundary_1.guardPublic)('history.addMessages', () => (0, add_messages_1.addMessages)(this.context, sessionId, messages, options?.signal));
-    }
-    /** Append one message; see {@link addMessages}. */
-    addMessage(sessionId, message, options) {
-        return (0, boundary_1.guardPublic)('history.addMessage', () => (0, add_messages_1.addMessages)(this.context, sessionId, [message], options?.signal));
-    }
-    /**
-     * Delete a session's messages, metadata and offloaded objects. Single pass:
-     * call it when the session is quiescent.
-     * @throws BatchWriteAllIncompleteError when a delete batch does not fully drain; UpstreamError; AbortError.
-     */
-    clear(sessionId, options) {
-        return (0, boundary_1.guardPublic)('history.clear', () => (0, clear_1.clearSession)(this.context, sessionId, options));
-    }
-    /**
-     * List every session as a metadata summary, most recently updated first.
-     * A table scan: cross-tenant by construction and bounded by `maxItems` /
-     * `maxIterations`.
-     * @throws ResultTruncatedError past either cap; UpstreamError; AbortError.
-     */
-    listSessions(options) {
-        return (0, boundary_1.guardPublic)('history.listSessions', () => (0, list_sessions_1.listSessions)(this.context, options));
-    }
-    /**
-     * Recompute and repair a session's `messageCount` from the stored messages.
-     * A maintenance tool for external corruption; run it when the session is idle.
-     * @throws ConflictError when the session does not exist or changed while counting; UpstreamError; AbortError.
-     */
-    reconcileMessageCount(sessionId, options) {
-        return (0, boundary_1.guardPublic)('history.reconcileMessageCount', () => (0, reconcile_count_1.reconcileMessageCount)(this.context, sessionId, options?.signal));
-    }
-    /**
-     * Get a single-session LangChain adapter for `sessionId`. `{ limit }` bounds
-     * what the adapter feeds the chain to the newest `limit` messages.
-     */
-    forSession(sessionId, window) {
-        return new session_adapter_1.DynamoDBSessionChatMessageHistory(this, sessionId, window);
-    }
-    /** Release owned resources (the underlying client and any S3 client). */
-    destroy() {
-        this.context.offloader?.destroy();
-        if (this.ownsClient)
-            this.ddbClient?.destroy();
-    }
-    /**
-     * Provision an S3 lifecycle expiration rule matching the configured TTL, so
-     * offloaded objects don't outlive their DynamoDB item forever. No-ops when
-     * S3 offload or TTL isn't configured; throws when the bucket cannot be read
-     * or written. Requires the `s3:GetLifecycleConfiguration` /
-     * `s3:PutLifecycleConfiguration` bucket-level permissions (broader than the
-     * object-level CRUD the rest of S3 offload needs) — call this once during
-     * deployment/provisioning, not per-request.
-     */
-    async ensureS3LifecycleRule() {
-        return (0, boundary_1.guardPublic)('history.ensureS3LifecycleRule', async () => {
-            if (!this.context.offloader || !this.context.ttl)
-                return;
-            await this.context.offloader.ensureLifecycleRule((0, ttl_1.lifecycleExpirationDays)(this.context.ttl));
-        });
-    }
-}
-exports.DynamoDBChatMessageHistory = DynamoDBChatMessageHistory;

package/dist/history/internal/append-saga.d.ts

@@ -1,25 +0,0 @@
-import type { ChatMessageItem } from '../types';
-import type { HistoryContext } from './setup';
-/** Shared per-append metadata applied to every chunk's session update. */
-export interface AppendFields {
-    now: string;
-    title?: string;
-    ttlTimestamp?: number;
-    forceTtlRefresh?: boolean;
-}
-/**
- * Append message chunks with caller-observed atomicity. Each chunk commits its
- * messages and count in one transaction; if a later chunk fails, every
- * already-committed chunk is deleted and its count reverted, and the batch's
- * S3 objects are cleaned once their rows are gone, restoring the pre-call
- * state before the error is rethrown. Except on a failed rollback, which
- * surfaces as {@link CompensationFailedError} and deliberately leaves the
- * committed chunks' S3 objects behind, since their rows may survive.
- *
- * A `RetryExhaustedError` is ambiguous — the transaction may have committed
- * and lost its response — so the chunk is read back first: present means it
- * committed (continue), absent means it did not (compensate), and a failed
- * read compensates but leaks that chunk's objects rather than delete objects
- * its possibly-live rows reference.
- */
-export declare function appendChunks(context: HistoryContext, sessionId: string, chunks: ChatMessageItem[][], fields: AppendFields, signal?: AbortSignal): Promise<void>;

package/dist/history/internal/append-saga.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendChunks = appendChunks;
-const retry_1 = require("../../shared/dynamodb/retry");
-const error_code_1 = require("../../shared/errors/error-code");
-const wrap_error_1 = require("../../shared/errors/wrap-error");
-const compensation_1 = require("./compensation");
-const message_transaction_1 = require("./message-transaction");
-/** True for the one failure shape that leaves the outcome ambiguous. */
-function isAmbiguous(error) {
-    return error.code === error_code_1.ErrorCode.RETRY_EXHAUSTED;
-}
-/**
- * Read the chunk's first row back with `ConsistentRead`. A chunk commits
- * atomically, so one row present means the whole chunk (and its count `ADD`)
- * landed and only the response was lost. Message sort keys are per-call
- * ULIDs, so a present row can only be this call's own.
- */
-async function verifyChunkLanded(context, chunk) {
-    try {
-        const result = await (0, retry_1.withDynamoDBRetry)(() => context.client.get({
-            TableName: context.tableName,
-            Key: { PK: chunk[0].PK, SK: chunk[0].SK },
-            ConsistentRead: true,
-            ProjectionExpression: '#sk',
-            ExpressionAttributeNames: { '#sk': 'SK' },
-        }), context.retry);
-        return result.Item ? 'committed' : 'not-committed';
-    }
-    catch {
-        return 'unverified';
-    }
-}
-/** Run one chunk's transaction, returning its error instead of throwing. */
-async function commitChunk(context, sessionId, chunk, fields, signal) {
-    try {
-        await (0, message_transaction_1.writeMessageChunk)(context, chunk, { ...fields, sessionId, count: chunk.length }, { signal });
-        return undefined;
-    }
-    catch (error) {
-        return (0, wrap_error_1.toError)(error);
-    }
-}
-function asCommitted(chunk) {
-    return { keys: chunk.map((item) => ({ PK: item.PK, SK: item.SK })), count: chunk.length };
-}
-/**
- * Append message chunks with caller-observed atomicity. Each chunk commits its
- * messages and count in one transaction; if a later chunk fails, every
- * already-committed chunk is deleted and its count reverted, and the batch's
- * S3 objects are cleaned once their rows are gone, restoring the pre-call
- * state before the error is rethrown. Except on a failed rollback, which
- * surfaces as {@link CompensationFailedError} and deliberately leaves the
- * committed chunks' S3 objects behind, since their rows may survive.
- *
- * A `RetryExhaustedError` is ambiguous — the transaction may have committed
- * and lost its response — so the chunk is read back first: present means it
- * committed (continue), absent means it did not (compensate), and a failed
- * read compensates but leaks that chunk's objects rather than delete objects
- * its possibly-live rows reference.
- */
-async function appendChunks(context, sessionId, chunks, fields, signal) {
-    const committed = [];
-    for (const chunk of chunks) {
-        const failure = await commitChunk(context, sessionId, chunk, fields, signal);
-        if (!failure) {
-            committed.push(asCommitted(chunk));
-            continue;
-        }
-        const verdict = isAmbiguous(failure)
-            ? await verifyChunkLanded(context, chunk)
-            : 'not-committed';
-        if (verdict === 'committed') {
-            committed.push(asCommitted(chunk));
-            continue;
-        }
-        await (0, compensation_1.compensate)(context, sessionId, chunks, committed, failure, fields.now, fields.title, verdict === 'unverified');
-    }
-}

package/dist/history/internal/compensation.d.ts

@@ -1,25 +0,0 @@
-import type { ChatMessageItem } from '../types';
-import type { HistoryContext } from './setup';
-/** A chunk that committed, retained so it can be rolled back on a later failure. */
-export interface CommittedChunk {
-    keys: {
-        PK: string;
-        SK: string;
-    }[];
-    count: number;
-}
-/**
- * Undo a failed batch. Always throws. S3 cleanup is split by commit status so
- * no live row is ever left pointing at a deleted object: the never-committed
- * suffix is cleaned immediately, the committed prefix only after its rows are
- * confirmed deleted. If the rollback itself fails, the committed chunks' S3
- * objects are deliberately left in place (their rows may survive) and it
- * raises {@link CompensationFailedError} carrying both the trigger and the
- * rollback error; otherwise it rethrows the trigger.
- *
- * `uncertain` marks the failed chunk (`chunks[committed.length]`) as one whose
- * outcome could not be verified: its rows may be live, so its objects are
- * leaked rather than deleted, while the never-attempted chunks after it are
- * still cleaned.
- */
-export declare function compensate(context: HistoryContext, sessionId: string, chunks: ChatMessageItem[][], committed: CommittedChunk[], trigger: Error, now: string, title: string | undefined, uncertain: boolean): Promise<never>;

package/dist/history/internal/compensation.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compensate = compensate;
-const descriptor_keys_1 = require("../../shared/codec/descriptor-keys");
-const orphans_1 = require("../../shared/codec/s3/orphans");
-const batch_write_1 = require("../../shared/dynamodb/batch-write");
-const errors_1 = require("../../shared/errors/errors");
-const wrap_error_1 = require("../../shared/errors/wrap-error");
-const session_count_1 = require("./session-count");
-/**
- * Best-effort delete the offloaded S3 objects of the `chunks` slice given.
- * {@link compensate} calls it once per commit status, never for the whole
- * batch, so a committed chunk's objects arrive only once its rows are gone.
- */
-async function cleanBatchS3(context, chunks) {
-    if (!context.offloader)
-        return;
-    const descriptors = chunks.flat().map((item) => item.message);
-    await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)(descriptors), 'history.addMessages', context.logger);
-}
-/**
- * Delete every committed chunk's items, then undo their effect on the session
- * row — deleting it outright when this call created it (see
- * {@link revertSessionCreation}), so a failed first append leaves no ghost
- * session holding the rolled-back message's title. A *partial* delete is not a
- * clean creation to undo, so that branch reverts only the count.
- */
-async function rollbackCommitted(context, sessionId, committed, now, title) {
-    const keys = committed.flatMap((chunk) => chunk.keys);
-    const total = committed.reduce((sum, chunk) => sum + chunk.count, 0);
-    if (keys.length === 0) {
-        await (0, session_count_1.revertSessionCreation)(context, sessionId, total, now, title);
-        return;
-    }
-    try {
-        await (0, batch_write_1.batchWriteAll)(context.client, context.tableName, keys.map((Key) => ({ DeleteRequest: { Key } })), { retry: context.retry });
-    }
-    catch (error) {
-        /**
-         * batchWriteAll has exactly one throw site and it is always a
-         * BatchWriteAllIncompleteError (see Task 9) — asserted, not instanceof-
-         * checked, since the false case is unreachable and this project
-         * enforces 100% branch coverage with no exceptions.
-         */
-        const deleted = error.succeededCount;
-        await (0, session_count_1.revertSessionCount)(context, sessionId, deleted, now);
-        throw error;
-    }
-    await (0, session_count_1.revertSessionCreation)(context, sessionId, total, now, title);
-}
-/**
- * Undo a failed batch. Always throws. S3 cleanup is split by commit status so
- * no live row is ever left pointing at a deleted object: the never-committed
- * suffix is cleaned immediately, the committed prefix only after its rows are
- * confirmed deleted. If the rollback itself fails, the committed chunks' S3
- * objects are deliberately left in place (their rows may survive) and it
- * raises {@link CompensationFailedError} carrying both the trigger and the
- * rollback error; otherwise it rethrows the trigger.
- *
- * `uncertain` marks the failed chunk (`chunks[committed.length]`) as one whose
- * outcome could not be verified: its rows may be live, so its objects are
- * leaked rather than deleted, while the never-attempted chunks after it are
- * still cleaned.
- */
-async function compensate(context, sessionId, chunks, committed, trigger, now, title, uncertain) {
-    if (committed.length > 0) {
-        context.logger.warn('history.addMessages compensating committed chunks after a chunk failed', {
-            sessionId,
-            committedChunks: committed.length,
-        });
-    }
-    /**
-     * The never-attempted suffix never had a DynamoDB row, so it is safe to
-     * clean now; an uncertain failed chunk is skipped because its rows may live.
-     */
-    const firstDead = committed.length + (uncertain ? 1 : 0);
-    await cleanBatchS3(context, chunks.slice(firstDead));
-    try {
-        await rollbackCommitted(context, sessionId, committed, now, title);
-    }
-    catch (rollbackError) {
-        context.logger.error('history.addMessages rollback failed; messageCount may have drifted', {
-            sessionId,
-            committedChunks: committed.length,
-        });
-        /** Skip S3 cleanup here: rollback may have failed, so committed rows might still reference these objects. */
-        throw new errors_1.CompensationFailedError(trigger, (0, wrap_error_1.toError)(rollbackError));
-    }
-    /** Only now that committed rows are confirmed deleted is it safe to delete their S3 objects. */
-    await cleanBatchS3(context, chunks.slice(0, committed.length));
-    throw trigger;
-}

package/dist/history/internal/item-mapper.d.ts

@@ -1,9 +0,0 @@
-import type { StoredMessage } from '@langchain/core/messages';
-import type { ChatMessageItem } from '../types';
-import type { HistoryContext } from './setup';
-/**
- * Encode a single stored message into its DynamoDB item, keyed by the session
- * partition and a `MSG#<ulid>` sort key. A `ttlTimestamp` stamps the uniform
- * whole-conversation expiry shared by every message in the session.
- */
-export declare function buildMessageItem(context: HistoryContext, sessionId: string, ulid: string, message: StoredMessage, ttlTimestamp?: number): Promise<ChatMessageItem>;

package/dist/history/internal/item-mapper.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMessageItem = buildMessageItem;
-const encode_1 = require("../../shared/codec/encode");
-const keys_1 = require("./keys");
-function codecDeps(context) {
-    return { serde: context.serde, compression: context.compression, offloader: context.offloader };
-}
-/**
- * Encode a single stored message into its DynamoDB item, keyed by the session
- * partition and a `MSG#<ulid>` sort key. A `ttlTimestamp` stamps the uniform
- * whole-conversation expiry shared by every message in the session.
- */
-async function buildMessageItem(context, sessionId, ulid, message, ttlTimestamp) {
-    const descriptor = await (0, encode_1.encodePayload)(message, codecDeps(context), {
-        keyParts: [sessionId, ulid],
-    });
-    const item = {
-        PK: (0, keys_1.sessionPartition)(sessionId),
-        SK: (0, keys_1.messageSortKey)(ulid),
-        sessionId,
-        message: descriptor,
-    };
-    if (ttlTimestamp !== undefined)
-        item.ttl = ttlTimestamp;
-    return item;
-}

package/dist/history/internal/keys.d.ts

@@ -1,16 +0,0 @@
-/** Reserved separator joining sort-key segments; forbidden inside a session id. */
-export declare const SORT_KEY_SEPARATOR = "#";
-/** Fixed sort key for the per-session metadata item. */
-export declare const SESSION_SORT_KEY = "HISTORY#SESSION";
-/** Partition key for a chat session: the adapter tag plus the session id. */
-export declare function sessionPartition(sessionId: string): string;
-/** Sort key for a single message item, ordered by its monotonic ULID. */
-export declare function messageSortKey(ulid: string): string;
-/**
- * True when `sortKey` is one this adapter writes. A partition query carries no
- * sort-key condition, so a partition-wide delete uses this to leave any row it
- * does not own in place rather than deleting the whole partition blindly.
- */
-export declare function isHistorySortKey(sortKey: string): boolean;
-/** `begins_with` prefix selecting every message item in a session. */
-export declare function messageSortKeyPrefix(): string;

package/dist/history/internal/keys.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_SORT_KEY = exports.SORT_KEY_SEPARATOR = void 0;
-exports.sessionPartition = sessionPartition;
-exports.messageSortKey = messageSortKey;
-exports.isHistorySortKey = isHistorySortKey;
-exports.messageSortKeyPrefix = messageSortKeyPrefix;
-/** Reserved separator joining sort-key segments; forbidden inside a session id. */
-exports.SORT_KEY_SEPARATOR = '#';
-/**
- * Item-kind tag distinguishing this adapter's sort keys from another
- * adapter's on a table shared via `DynamoDBFactory.createAll()` — matches the
- * pattern the checkpointer module already uses for its own META#/PAYLOAD#/
- * WRITE# keys. Without it, `SESSION_SORT_KEY` alone was a bare, common-word
- * literal a store caller could produce by accident (e.g.
- * `store.put([sessionId], 'SESSION', ...)`, since `sortKey` collapses a
- * single-element namespace down to just the key).
- */
-const ADAPTER_PREFIX = `HISTORY${exports.SORT_KEY_SEPARATOR}`;
-/** Fixed sort key for the per-session metadata item. */
-exports.SESSION_SORT_KEY = `${ADAPTER_PREFIX}SESSION`;
-const MESSAGE_PREFIX = `${ADAPTER_PREFIX}MSG#`;
-/**
- * Adapter tag prefixed to every chat-history partition key — see the
- * equivalent in checkpointer/internal/keys.ts for why the three adapters'
- * partitions must not overlap on a shared table.
- */
-const ADAPTER_PARTITION_PREFIX = `HIST${exports.SORT_KEY_SEPARATOR}`;
-/** Partition key for a chat session: the adapter tag plus the session id. */
-function sessionPartition(sessionId) {
-    return `${ADAPTER_PARTITION_PREFIX}${sessionId}`;
-}
-/** Sort key for a single message item, ordered by its monotonic ULID. */
-function messageSortKey(ulid) {
-    return `${MESSAGE_PREFIX}${ulid}`;
-}
-/**
- * True when `sortKey` is one this adapter writes. A partition query carries no
- * sort-key condition, so a partition-wide delete uses this to leave any row it
- * does not own in place rather than deleting the whole partition blindly.
- */
-function isHistorySortKey(sortKey) {
-    return sortKey.startsWith(ADAPTER_PREFIX);
-}
-/** `begins_with` prefix selecting every message item in a session. */
-function messageSortKeyPrefix() {
-    return MESSAGE_PREFIX;
-}