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

package/dist/checkpointer/saver.d.ts

@@ -1,70 +0,0 @@
-import type { RunnableConfig } from '@langchain/core/runnables';
-import { BaseCheckpointSaver, type ChannelVersions, type Checkpoint, type CheckpointListOptions, type CheckpointMetadata, type CheckpointTuple, type PendingWrite } from '@langchain/langgraph-checkpoint';
-import type { CancelOptions } from '../shared/options';
-import type { DynamoDBSaverOptions } from './types';
-/**
- * DynamoDB-backed LangGraph checkpoint saver. A thin orchestrator: it resolves
- * its collaborators once and delegates every operation to a focused action.
- * Every public method is the library's error boundary — a raw AWS SDK error
- * escaping an action surfaces as an `UpstreamError`.
- */
-export declare class DynamoDBSaver extends BaseCheckpointSaver {
-    private readonly context;
-    private readonly ownsClient;
-    private readonly ddbClient;
-    constructor(options: DynamoDBSaverOptions);
-    /**
-     * Read one checkpoint with its metadata and pending writes: the one
-     * `checkpoint_id` names, else the newest in the namespace. Strongly
-     * consistent, so a checkpoint just written is always seen. Returns
-     * `undefined` for an unknown thread or checkpoint, or a config without a
-     * thread.
-     * @throws ValidationError for a malformed identifier; UpstreamError, RetryExhaustedError, AbortError (`config.signal`).
-     */
-    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
-    /**
-     * Stream checkpoints newest first: one namespace, every namespace of a
-     * thread when `checkpoint_ns` is omitted, or every thread in the table when
-     * `thread_id` is omitted (a table scan). Eventually consistent. `before`,
-     * `filter` and `limit` follow the reference savers.
-     * @remarks One read per page plus two per yielded tuple (see the README cost table).
-     * @throws ValidationError, UpstreamError, RetryExhaustedError, AbortError.
-     */
-    list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
-    /**
-     * Store a checkpoint and its metadata in one transaction and return the
-     * config that addresses it. `config.checkpoint_id` becomes the parent;
-     * `newVersions` names the channels that changed, and only those plus the
-     * ones the parent stored are persisted. Last writer wins for a repeated
-     * `checkpoint_id`.
-     * @throws ValidationError; UpstreamError; RetryExhaustedError; AbortError; S3_OFFLOAD_FAILED when an offloaded payload cannot be uploaded.
-     */
-    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, newVersions?: ChannelVersions): Promise<RunnableConfig>;
-    /**
-     * Store a task's pending writes for the checkpoint `config` names, one row
-     * per write, written in parallel. Regular writes are first-write-wins;
-     * special channels (`__interrupt__`, `__resume__`, `__error__`,
-     * `__scheduled__`) overwrite, guarded so two concurrent calls never orphan
-     * an offloaded object.
-     * @throws ValidationError when `checkpoint_id` is missing or a channel is malformed; UpstreamError; RetryExhaustedError; AbortError.
-     */
-    putWrites(config: RunnableConfig, writes: PendingWrite[], taskId: string): Promise<void>;
-    /**
-     * Delete every checkpoint, payload and pending write of a thread and their
-     * offloaded objects. Single pass: call it when the thread is quiescent.
-     * @throws BatchWriteAllIncompleteError when a delete batch does not fully drain; UpstreamError; AbortError (`options.signal`).
-     */
-    deleteThread(threadId: string, options?: CancelOptions): Promise<void>;
-    /** 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/checkpointer/saver.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBSaver = void 0;
-const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
-const boundary_1 = require("../shared/errors/boundary");
-const ttl_1 = require("../shared/validation/ttl");
-const delete_thread_1 = require("./actions/delete-thread");
-const get_tuple_1 = require("./actions/get-tuple");
-const list_1 = require("./actions/list");
-const put_1 = require("./actions/put");
-const put_writes_1 = require("./actions/put-writes");
-const setup_1 = require("./internal/setup");
-/**
- * DynamoDB-backed LangGraph checkpoint saver. A thin orchestrator: it resolves
- * its collaborators once and delegates every operation to a focused action.
- * Every public method is the library's error boundary — a raw AWS SDK error
- * escaping an action surfaces as an `UpstreamError`.
- */
-class DynamoDBSaver extends langgraph_checkpoint_1.BaseCheckpointSaver {
-    context;
-    ownsClient;
-    ddbClient;
-    constructor(options) {
-        super(options.serde);
-        const setup = (0, setup_1.setUpCheckpointer)(options, this.serde);
-        this.context = setup.context;
-        this.ownsClient = setup.ownsClient;
-        this.ddbClient = setup.ddbClient;
-    }
-    /**
-     * Read one checkpoint with its metadata and pending writes: the one
-     * `checkpoint_id` names, else the newest in the namespace. Strongly
-     * consistent, so a checkpoint just written is always seen. Returns
-     * `undefined` for an unknown thread or checkpoint, or a config without a
-     * thread.
-     * @throws ValidationError for a malformed identifier; UpstreamError, RetryExhaustedError, AbortError (`config.signal`).
-     */
-    async getTuple(config) {
-        return (0, boundary_1.guardPublic)('saver.getTuple', () => (0, get_tuple_1.getCheckpointTuple)(this.context, config));
-    }
-    /**
-     * Stream checkpoints newest first: one namespace, every namespace of a
-     * thread when `checkpoint_ns` is omitted, or every thread in the table when
-     * `thread_id` is omitted (a table scan). Eventually consistent. `before`,
-     * `filter` and `limit` follow the reference savers.
-     * @remarks One read per page plus two per yielded tuple (see the README cost table).
-     * @throws ValidationError, UpstreamError, RetryExhaustedError, AbortError.
-     */
-    list(config, options) {
-        return (0, boundary_1.guardPublicIterable)('saver.list', (0, list_1.listCheckpoints)(this.context, config, options));
-    }
-    /**
-     * Store a checkpoint and its metadata in one transaction and return the
-     * config that addresses it. `config.checkpoint_id` becomes the parent;
-     * `newVersions` names the channels that changed, and only those plus the
-     * ones the parent stored are persisted. Last writer wins for a repeated
-     * `checkpoint_id`.
-     * @throws ValidationError; UpstreamError; RetryExhaustedError; AbortError; S3_OFFLOAD_FAILED when an offloaded payload cannot be uploaded.
-     */
-    async put(config, checkpoint, metadata, newVersions) {
-        return (0, boundary_1.guardPublic)('saver.put', () => (0, put_1.putCheckpoint)(this.context, config, checkpoint, metadata, newVersions));
-    }
-    /**
-     * Store a task's pending writes for the checkpoint `config` names, one row
-     * per write, written in parallel. Regular writes are first-write-wins;
-     * special channels (`__interrupt__`, `__resume__`, `__error__`,
-     * `__scheduled__`) overwrite, guarded so two concurrent calls never orphan
-     * an offloaded object.
-     * @throws ValidationError when `checkpoint_id` is missing or a channel is malformed; UpstreamError; RetryExhaustedError; AbortError.
-     */
-    async putWrites(config, writes, taskId) {
-        return (0, boundary_1.guardPublic)('saver.putWrites', () => (0, put_writes_1.putWrites)(this.context, config, writes, taskId));
-    }
-    /**
-     * Delete every checkpoint, payload and pending write of a thread and their
-     * offloaded objects. Single pass: call it when the thread is quiescent.
-     * @throws BatchWriteAllIncompleteError when a delete batch does not fully drain; UpstreamError; AbortError (`options.signal`).
-     */
-    async deleteThread(threadId, options) {
-        return (0, boundary_1.guardPublic)('saver.deleteThread', () => (0, delete_thread_1.deleteThread)(this.context, threadId, options));
-    }
-    /** 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)('saver.ensureS3LifecycleRule', async () => {
-            if (!this.context.offloader || !this.context.ttl)
-                return;
-            await this.context.offloader.ensureLifecycleRule((0, ttl_1.lifecycleExpirationDays)(this.context.ttl));
-        });
-    }
-}
-exports.DynamoDBSaver = DynamoDBSaver;

package/dist/checkpointer/types.d.ts

@@ -1,58 +0,0 @@
-import type { SerializerProtocol } from '@langchain/langgraph-checkpoint';
-import type { PayloadDescriptor } from '../shared/codec/codec';
-import type { BaseAdapterOptions, CodecOptions } from '../shared/options';
-/** Options for {@link DynamoDBSaver}. */
-export type DynamoDBSaverOptions = BaseAdapterOptions & CodecOptions & {
-    /** Optional serializer override (defaults to LangGraph's JSON serializer). */
-    serde?: SerializerProtocol;
-};
-/** Narrowed shape of `RunnableConfig.configurable` the saver relies on. */
-export interface CheckpointConfigurable {
-    thread_id: string;
-    checkpoint_ns?: string;
-    checkpoint_id?: string;
-    /** Legacy alias of `checkpoint_id` that older callers and API-shaped configs still emit. */
-    thread_ts?: string;
-}
-/** The lightweight `META#` item: structural fields + serialized metadata. */
-export interface CheckpointMetaItem {
-    PK: string;
-    SK: string;
-    threadId: string;
-    checkpointNs: string;
-    checkpointId: string;
-    parentCheckpointId?: string;
-    metadata: PayloadDescriptor;
-    /**
-     * The channels whose values the PAYLOAD row holds: those the put's
-     * `newVersions` named plus those carried over from the parent. Absent on
-     * rows written before this attribute, which hold every value they were given.
-     */
-    storedChannels?: string[];
-    ttl?: number;
-}
-/** The heavy `PAYLOAD#` item: the serialized checkpoint. */
-export interface CheckpointPayloadItem {
-    PK: string;
-    SK: string;
-    checkpoint: PayloadDescriptor;
-    ttl?: number;
-}
-/** A `WRITE#` item: one pending write for a checkpoint/task. */
-export interface CheckpointWriteItem {
-    PK: string;
-    SK: string;
-    taskId: string;
-    index: number;
-    channel: string;
-    /** Identifies the `putWrites` call that produced this row (see item-writer). */
-    writeGroup: string;
-    /**
-     * How many earlier writes in the same call already used this channel.
-     * Optional: rows written before 0.9.0 carry none and read back as 0, which
-     * is exactly the identity they were stored under.
-     */
-    occurrence?: number;
-    value: PayloadDescriptor;
-    ttl?: number;
-}

package/dist/factory/factory.d.ts

@@ -1,40 +0,0 @@
-import { DynamoDBSaver } from '../checkpointer/saver';
-import type { DynamoDBSaverOptions } from '../checkpointer/types';
-import { DynamoDBChatMessageHistory } from '../history/chat-message-history';
-import type { DynamoDBChatMessageHistoryOptions } from '../history/types';
-import { DynamoDBStore } from '../store/store';
-import type { DynamoDBStoreOptions } from '../store/types';
-import type { CreateAllOptions, CreatedAdapters, FactoryBaseOptions } from './types';
-/**
- * Convenience constructors for the adapters. Individual `create*` methods each
- * build their own client; {@link createAll} builds one shared client used by all
- * three and returns a combined `destroy` that tears everything down once.
- */
-export declare class DynamoDBFactory {
-    private readonly base;
-    constructor(base?: FactoryBaseOptions);
-    /** The base options every adapter inherits regardless of which client it uses. */
-    private sharedDefaults;
-    /**
-     * Per-adapter options replace the factory's client choice as a unit: a
-     * `client` handed to `createSaver` also displaces the base `clientConfig`
-     * and `createClient`, because carrying those along is exactly the ambiguous
-     * combination the adapters' option validation rejects. The shared
-     * `ttl`/`compression`/`s3`/`retry` defaults stay either way.
-     */
-    private defaultsFor;
-    /** A saver on its own client, with the factory's shared defaults underneath `options`. */
-    createSaver(options: DynamoDBSaverOptions): DynamoDBSaver;
-    /** A store on its own client, with the factory's shared defaults underneath `options`. */
-    createStore(options: DynamoDBStoreOptions): DynamoDBStore;
-    /** A chat history on its own client, with the factory's shared defaults underneath `options`. */
-    createChatMessageHistory(options: DynamoDBChatMessageHistoryOptions): DynamoDBChatMessageHistory;
-    /**
-     * Build the adapters whose sections are given, all on one shared client and
-     * with the factory's shared defaults underneath each section. If any
-     * constructor throws (a store with `vectorBackend` but no `index`, say), the
-     * adapters already built and the freshly created client are destroyed
-     * before the error propagates, so a failed call leaks nothing.
-     */
-    createAll<O extends CreateAllOptions>(options: O): CreatedAdapters<O>;
-}

package/dist/factory/factory.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBFactory = void 0;
-const saver_1 = require("../checkpointer/saver");
-const chat_message_history_1 = require("../history/chat-message-history");
-const client_1 = require("../shared/dynamodb/client");
-const store_1 = require("../store/store");
-function overridesClient(options) {
-    return (options.client !== undefined ||
-        options.clientConfig !== undefined ||
-        options.createClient !== undefined);
-}
-/**
- * Convenience constructors for the adapters. Individual `create*` methods each
- * build their own client; {@link createAll} builds one shared client used by all
- * three and returns a combined `destroy` that tears everything down once.
- */
-class DynamoDBFactory {
-    base;
-    constructor(base = {}) {
-        this.base = base;
-    }
-    /** The base options every adapter inherits regardless of which client it uses. */
-    sharedDefaults() {
-        const { logger, ttl, compression, s3, retry } = this.base;
-        return { logger, ttl, compression, s3, retry };
-    }
-    /**
-     * Per-adapter options replace the factory's client choice as a unit: a
-     * `client` handed to `createSaver` also displaces the base `clientConfig`
-     * and `createClient`, because carrying those along is exactly the ambiguous
-     * combination the adapters' option validation rejects. The shared
-     * `ttl`/`compression`/`s3`/`retry` defaults stay either way.
-     */
-    defaultsFor(options) {
-        return overridesClient(options) ? this.sharedDefaults() : this.base;
-    }
-    /** A saver on its own client, with the factory's shared defaults underneath `options`. */
-    createSaver(options) {
-        return new saver_1.DynamoDBSaver({ ...this.defaultsFor(options), ...options });
-    }
-    /** A store on its own client, with the factory's shared defaults underneath `options`. */
-    createStore(options) {
-        return new store_1.DynamoDBStore({ ...this.defaultsFor(options), ...options });
-    }
-    /** A chat history on its own client, with the factory's shared defaults underneath `options`. */
-    createChatMessageHistory(options) {
-        return new chat_message_history_1.DynamoDBChatMessageHistory({ ...this.defaultsFor(options), ...options });
-    }
-    /**
-     * Build the adapters whose sections are given, all on one shared client and
-     * with the factory's shared defaults underneath each section. If any
-     * constructor throws (a store with `vectorBackend` but no `index`, say), the
-     * adapters already built and the freshly created client are destroyed
-     * before the error propagates, so a failed call leaks nothing.
-     */
-    createAll(options) {
-        const resolved = (0, client_1.resolveDynamoDBClient)(this.base);
-        const shared = { ...this.sharedDefaults(), client: resolved.client };
-        const built = [];
-        /** Record an adapter the moment it exists, so a later failure can still tear it down. */
-        const track = (adapter) => {
-            built.push(adapter);
-            return adapter;
-        };
-        const destroy = () => {
-            for (const adapter of built)
-                adapter.destroy();
-            resolved.ddbClient?.destroy();
-        };
-        const { saver, store, history } = options;
-        try {
-            const adapters = {
-                saver: saver && track(new saver_1.DynamoDBSaver({ ...shared, ...saver })),
-                store: store && track(new store_1.DynamoDBStore({ ...shared, ...store })),
-                history: history && track(new chat_message_history_1.DynamoDBChatMessageHistory({ ...shared, ...history })),
-                destroy,
-            };
-            return adapters;
-        }
-        catch (error) {
-            destroy();
-            throw error;
-        }
-    }
-}
-exports.DynamoDBFactory = DynamoDBFactory;

package/dist/history/actions/add-messages.d.ts

@@ -1,15 +0,0 @@
-import { type BaseMessage } from '@langchain/core/messages';
-import type { HistoryContext } from '../internal/setup';
-/**
- * Append messages as one item per message. Each chunk writes its message Puts
- * and the session-metadata count `ADD` in a single `TransactWriteItems`, so
- * `messageCount` can never disagree with the stored messages. A creation-anchored
- * TTL (resolved by read, set in the transaction via `if_not_exists`) gives every
- * item one shared expiry. Batches larger than the 100-item / 4 MB transaction
- * limits are split into chunks and applied with caller-observed atomicity: if a
- * later chunk fails, the committed chunks are rolled back (see {@link appendChunks}).
- *
- * Per item the 400 KB DynamoDB limit still applies; enable S3 offloading so
- * large payloads become small descriptors and stay well under the limits.
- */
-export declare function addMessages(context: HistoryContext, sessionId: string, messages: BaseMessage[], signal?: AbortSignal): Promise<void>;

package/dist/history/actions/add-messages.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addMessages = addMessages;
-const messages_1 = require("@langchain/core/messages");
-const clock_1 = require("../../shared/clock");
-const descriptor_keys_1 = require("../../shared/codec/descriptor-keys");
-const orphans_1 = require("../../shared/codec/s3/orphans");
-const ttl_1 = require("../../shared/validation/ttl");
-const append_saga_1 = require("../internal/append-saga");
-const item_mapper_1 = require("../internal/item-mapper");
-const message_chunker_1 = require("../internal/message-chunker");
-const title_generator_1 = require("../internal/title-generator");
-const ttl_anchor_1 = require("../internal/ttl-anchor");
-const validation_1 = require("../internal/validation");
-/** Message Puts per append transaction: the 100-item limit, less the metadata Update. */
-const MAX_MESSAGES_PER_TRANSACTION = 99;
-/**
- * Aggregate byte budget per transaction. Held ~500 KB below DynamoDB's 4 MB
- * `TransactWriteItems` ceiling so the conservative per-item estimate (see
- * `ITEM_OVERHEAD_BYTES`) cannot push a chunk over the real limit at commit time.
- */
-const MAX_TRANSACTION_BYTES = 3_500_000;
-/**
- * Encode every message, cleaning up after itself if one fails partway.
- *
- * Offloaded messages upload sequentially here, *before* the append saga's
- * compensation machinery is ever reached, so a failure on message N used to
- * strand messages 1..N-1's already-uploaded S3 objects with no cleanup path —
- * the one gap in this subsystem's otherwise complete no-orphan guarantee.
- * Nothing will ever reference those objects, so they are safe to delete
- * unconditionally on the way out.
- */
-async function buildItems(context, sessionId, stored, ttlTimestamp) {
-    const items = [];
-    try {
-        for (const message of stored) {
-            items.push(await (0, item_mapper_1.buildMessageItem)(context, sessionId, context.ulid(), message, ttlTimestamp));
-        }
-    }
-    catch (error) {
-        if (context.offloader) {
-            await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)(items.map((item) => item.message)), 'history.addMessages.encode', context.logger);
-        }
-        throw error;
-    }
-    return items;
-}
-/**
- * Append messages as one item per message. Each chunk writes its message Puts
- * and the session-metadata count `ADD` in a single `TransactWriteItems`, so
- * `messageCount` can never disagree with the stored messages. A creation-anchored
- * TTL (resolved by read, set in the transaction via `if_not_exists`) gives every
- * item one shared expiry. Batches larger than the 100-item / 4 MB transaction
- * limits are split into chunks and applied with caller-observed atomicity: if a
- * later chunk fails, the committed chunks are rolled back (see {@link appendChunks}).
- *
- * Per item the 400 KB DynamoDB limit still applies; enable S3 offloading so
- * large payloads become small descriptors and stay well under the limits.
- */
-async function addMessages(context, sessionId, messages, signal) {
-    (0, validation_1.validateSessionId)(sessionId);
-    if (messages.length === 0)
-        return;
-    const stored = (0, messages_1.mapChatMessagesToStoredMessages)(messages);
-    (0, validation_1.validateStorableMessages)(stored);
-    const anchor = context.ttl
-        ? await (0, ttl_anchor_1.resolveTtlAnchor)(context, sessionId, (0, ttl_1.calculateTtlTimestamp)(context.ttl), signal)
-        : undefined;
-    const items = await buildItems(context, sessionId, stored, anchor?.ttlTimestamp);
-    const chunks = (0, message_chunker_1.chunkBySize)(items, MAX_MESSAGES_PER_TRANSACTION, MAX_TRANSACTION_BYTES);
-    await (0, append_saga_1.appendChunks)(context, sessionId, chunks, {
-        now: (0, clock_1.nowIso)(),
-        title: (0, title_generator_1.deriveTitle)(stored),
-        ttlTimestamp: anchor?.ttlTimestamp,
-        forceTtlRefresh: anchor?.refresh,
-    }, signal);
-}

package/dist/history/actions/clear.d.ts

@@ -1,10 +0,0 @@
-import type { HistoryContext } from '../internal/setup';
-/**
- * Delete a whole session: every message item plus the metadata item, best-effort
- * deleting any offloaded S3 objects. Rows this adapter does not own are left in
- * place and logged, so a shared-table partition holding a foreign row is never
- * collaterally wiped.
- */
-export declare function clearSession(context: HistoryContext, sessionId: string, options?: {
-    signal?: AbortSignal;
-}): Promise<void>;

package/dist/history/actions/clear.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearSession = clearSession;
-const partition_delete_1 = require("../../shared/dynamodb/partition-delete");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const keys_1 = require("../internal/keys");
-const query_1 = require("../internal/query");
-const validation_1 = require("../internal/validation");
-/** The offloaded payload a chat-history row can reference. */
-function descriptorsOf(row) {
-    return [row.message];
-}
-/**
- * Delete a whole session: every message item plus the metadata item, best-effort
- * deleting any offloaded S3 objects. Rows this adapter does not own are left in
- * place and logged, so a shared-table partition holding a foreign row is never
- * collaterally wiped.
- */
-async function clearSession(context, sessionId, options = {}) {
-    (0, validation_1.validateSessionId)(sessionId);
-    await (0, partition_delete_1.deletePartitionRows)({
-        client: context.client,
-        tableName: context.tableName,
-        params: (0, query_1.sessionItemsQuery)(context.tableName, sessionId, { consistent: true }),
-        logger: context.logger,
-        retry: (0, retry_policy_1.retryFor)(context, options.signal),
-        signal: options.signal,
-        offloader: context.offloader,
-        operation: 'history.clear',
-        ownsSortKey: keys_1.isHistorySortKey,
-        descriptorsOf,
-        scope: [sessionId],
-    });
-}

package/dist/history/actions/get-messages.d.ts

@@ -1,17 +0,0 @@
-import { type BaseMessage } from '@langchain/core/messages';
-import type { CancelOptions } from '../../shared/options';
-import type { HistoryContext } from '../internal/setup';
-import type { MessageWindow } from '../types';
-/**
- * Return a session's messages in chronological order — the whole session, or
- * the window `options` selects: `limit` keeps only the newest `limit`
- * messages, `before` only those appended before that instant (see
- * {@link readWindow}). Items past their TTL are filtered out on read
- * (DynamoDB's background TTL sweep can lag by up to 48h), so the returned
- * history is never stale. A corrupt item — see
- * {@link decodeMessage} for exactly what counts — is handled per
- * `onCorruptMessage`: `'throw'` fails the read with the underlying error;
- * `'skip'` (the default) reports it at `error` with its sort key and returns
- * the rest. Every other failure propagates regardless of the policy.
- */
-export declare function getMessages(context: HistoryContext, sessionId: string, options?: MessageWindow & CancelOptions): Promise<BaseMessage[]>;

package/dist/history/actions/get-messages.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMessages = getMessages;
-const messages_1 = require("@langchain/core/messages");
-const codec_1 = require("../../shared/codec/codec");
-const payload_loss_1 = require("../../shared/codec/payload-loss");
-const concurrency_1 = require("../../shared/concurrency");
-const constants_1 = require("../../shared/constants");
-const wrap_error_1 = require("../../shared/errors/wrap-error");
-const message_window_1 = require("../internal/message-window");
-const validation_1 = require("../internal/validation");
-/**
- * Decode one item in two stages so failures are classified by what caused
- * them. Fetching the bytes (an S3 download, decompression) is infrastructure:
- * a transport, throttling or permission failure there is rethrown, because
- * dropping the message would hand the caller a silently truncated conversation
- * that `RunnableWithMessageHistory` then re-persists. Only a *permanent* loss
- * at that stage — the object is gone, or the decompression guard tripped — is
- * corruption. Deserializing and rebuilding the message is pure data handling,
- * so any failure there (bad bytes, a type LangChain cannot rebuild such as a
- * `RemoveMessage`) is corruption too, and is confined to that one message.
- */
-async function decodeMessage(context, item, sessionId) {
-    const deps = {
-        serde: context.serde,
-        compression: context.compression,
-        offloader: context.offloader,
-    };
-    let bytes;
-    try {
-        bytes = await (0, codec_1.readPayloadBytes)(item.message, deps, [sessionId]);
-    }
-    catch (error) {
-        if ((0, payload_loss_1.isPermanentPayloadLoss)(error))
-            return { kind: 'corrupt', error: error };
-        throw error;
-    }
-    try {
-        const stored = (await context.serde.loadsTyped(item.message.serdeType, bytes));
-        return { kind: 'ok', message: (0, messages_1.mapStoredMessagesToChatMessages)([stored])[0] };
-    }
-    catch (error) {
-        return { kind: 'corrupt', error: (0, wrap_error_1.toError)(error) };
-    }
-}
-/**
- * Return a session's messages in chronological order — the whole session, or
- * the window `options` selects: `limit` keeps only the newest `limit`
- * messages, `before` only those appended before that instant (see
- * {@link readWindow}). Items past their TTL are filtered out on read
- * (DynamoDB's background TTL sweep can lag by up to 48h), so the returned
- * history is never stale. A corrupt item — see
- * {@link decodeMessage} for exactly what counts — is handled per
- * `onCorruptMessage`: `'throw'` fails the read with the underlying error;
- * `'skip'` (the default) reports it at `error` with its sort key and returns
- * the rest. Every other failure propagates regardless of the policy.
- */
-async function getMessages(context, sessionId, options = {}) {
-    (0, validation_1.validateSessionId)(sessionId);
-    (0, validation_1.validateMessageWindow)(options);
-    const items = await (0, message_window_1.readWindow)(context, sessionId, options);
-    /** Offloaded rows cost one S3 GET each, so they decode several at a time; the policy is applied in order. */
-    const decoded = await (0, concurrency_1.mapWithConcurrency)(items, constants_1.DEFAULT_READ_CONCURRENCY, (item) => decodeMessage(context, item, sessionId));
-    const messages = [];
-    decoded.forEach((result, index) => {
-        if (result.kind === 'ok') {
-            messages.push(result.message);
-            return;
-        }
-        if (context.onCorruptMessage === 'throw')
-            throw result.error;
-        context.logger.error('getMessages: skipped a corrupt message item', {
-            sessionId,
-            sortKey: items[index].SK,
-            reason: result.error.name,
-        });
-    });
-    return messages;
-}

package/dist/history/actions/list-sessions.d.ts

@@ -1,13 +0,0 @@
-import type { HistoryContext } from '../internal/setup';
-import type { SessionMetadata } from '../types';
-/**
- * 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.
- */
-export declare function listSessions(context: HistoryContext, options?: {
-    maxIterations?: number;
-    maxItems?: number;
-    signal?: AbortSignal;
-}): Promise<SessionMetadata[]>;