@adminforth/agent 1.17.0 → 1.18.0

package/agent/checkpointer.ts

@@ -0,0 +1,328 @@
+import type { RunnableConfig } from "@langchain/core/runnables";
+import {
+  BaseCheckpointSaver,
+  type Checkpoint,
+  type CheckpointPendingWrite,
+  type CheckpointMetadata,
+  type CheckpointTuple,
+  type PendingWrite,
+  WRITES_IDX_MAP,
+} from "@langchain/langgraph-checkpoint";
+import type { PluginOptions } from "../types.js";
+import { Filters } from "adminforth";
+
+const ROOT_CHECKPOINT_NAMESPACE = "__root__";
+
+export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
+  constructor(
+    private readonly adminforth: any,
+    private readonly pluginOptions: PluginOptions,
+  ) {
+    super();
+  }
+
+  private get resourceConfig() {
+    const resource = this.pluginOptions.checkpointResource;
+    if (!resource) {
+      throw new Error("checkpointResource is not configured");
+    }
+    return resource;
+  }
+
+  private resource() {
+    return this.adminforth.resource(this.resourceConfig.resourceId);
+  }
+
+  private serialize(value: unknown): string | null {
+    if (value === undefined || value === null) return null;
+    return JSON.stringify(value);
+  }
+
+  private deserialize<T>(value: unknown): T | null {
+    if (value === undefined || value === null) return null;
+    if (typeof value === "string") {
+      return JSON.parse(value) as T;
+    }
+    return value as T;
+  }
+
+  private now(): string {
+    return new Date().toISOString();
+  }
+
+  private encodeCheckpointNamespace(checkpointNs: string): string {
+    return checkpointNs === "" ? ROOT_CHECKPOINT_NAMESPACE : checkpointNs;
+  }
+
+  private decodeCheckpointNamespace(checkpointNs: unknown): string {
+    return checkpointNs === ROOT_CHECKPOINT_NAMESPACE ? "" : String(checkpointNs ?? "");
+  }
+
+  private getConfigValues(config: RunnableConfig) {
+    const configurable = (config.configurable ?? {}) as Record<string, unknown>;
+
+    return {
+      threadId: String(configurable.thread_id ?? ""),
+      checkpointNs: String(configurable.checkpoint_ns ?? ""),
+      checkpointId: configurable.checkpoint_id
+        ? String(configurable.checkpoint_id)
+        : null,
+    };
+  }
+
+  private buildConfig(threadId: string, checkpointNs: string, checkpointId: string): RunnableConfig {
+    return {
+      configurable: {
+        thread_id: threadId,
+        checkpoint_ns: checkpointNs,
+        checkpoint_id: checkpointId,
+      },
+    };
+  }
+
+  private buildCheckpointRowId(threadId: string, checkpointNs: string, checkpointId: string) {
+    return `cp:${threadId}:${checkpointNs}:${checkpointId}`;
+  }
+
+  private buildWritesRowId(
+    threadId: string,
+    checkpointNs: string,
+    checkpointId: string,
+    taskId: string,
+    seq: number,
+  ) {
+    return `wr:${threadId}:${checkpointNs}:${checkpointId}:${taskId}:${seq}`;
+  }
+
+  private getWriteIndex(channel: string, index: number): number {
+    return WRITES_IDX_MAP[channel] ?? index;
+  }
+
+  private isDuplicateCheckpointWriteError(error: unknown): boolean {
+    return error instanceof Error && error.message.includes("UNIQUE constraint failed");
+  }
+
+  async put(
+    config: RunnableConfig,
+    checkpoint: Checkpoint,
+    metadata: CheckpointMetadata,
+    _newVersions: Record<string, unknown>,
+  ): Promise<RunnableConfig> {
+    const r = this.resourceConfig;
+    const { threadId, checkpointNs } = this.getConfigValues(config);
+    const checkpointId = String((checkpoint as any).id);
+    const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+
+    const parentCheckpointId = this.getConfigValues(config).checkpointId;
+    const createdAt = this.now();
+
+    await this.resource().create({
+      [r.idField]: this.buildCheckpointRowId(threadId, storedCheckpointNs, checkpointId),
+      [r.threadIdField]: threadId,
+      [r.checkpointNamespaceField]: storedCheckpointNs,
+      [r.checkpointIdField]: checkpointId,
+      [r.parentCheckpointIdField]: parentCheckpointId,
+      [r.rowKindField]: "checkpoint",
+      [r.taskIdField]: null,
+      [r.sequenceField]: 0,
+      [r.createdAtField]: createdAt,
+      [r.checkpointPayloadField]: this.serialize(checkpoint),
+      [r.metadataPayloadField]: this.serialize(metadata),
+      [r.writesPayloadField]: null,
+      [r.schemaVersionField]: 1,
+    });
+
+    return this.buildConfig(threadId, checkpointNs, checkpointId);
+  }
+
+  async putWrites(
+    config: RunnableConfig,
+    writes: PendingWrite[],
+    taskId: string,
+  ): Promise<void> {
+    const r = this.resourceConfig;
+    const { threadId, checkpointNs, checkpointId } = this.getConfigValues(config);
+    const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+
+    if (!checkpointId) {
+      throw new Error("putWrites requires checkpoint_id in config");
+    }
+
+    const createdAt = this.now();
+
+    await Promise.all(
+      writes.map(async ([channel, value], index) => {
+        const writeIndex = this.getWriteIndex(channel, index);
+
+        try {
+          await this.resource().create({
+            [r.idField]: this.buildWritesRowId(
+              threadId,
+              storedCheckpointNs,
+              checkpointId,
+              taskId,
+              writeIndex,
+            ),
+            [r.threadIdField]: threadId,
+            [r.checkpointNamespaceField]: storedCheckpointNs,
+            [r.checkpointIdField]: checkpointId,
+            [r.parentCheckpointIdField]: null,
+            [r.rowKindField]: "writes",
+            [r.taskIdField]: taskId,
+            [r.sequenceField]: writeIndex,
+            [r.createdAtField]: createdAt,
+            [r.checkpointPayloadField]: null,
+            [r.metadataPayloadField]: null,
+            [r.writesPayloadField]: this.serialize([channel, value] satisfies PendingWrite),
+            [r.schemaVersionField]: 1,
+          });
+        } catch (error) {
+          if (!this.isDuplicateCheckpointWriteError(error)) {
+            throw error;
+          }
+        }
+      }),
+    );
+  }
+
+  async getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined> {
+    const r = this.resourceConfig;
+    const { threadId, checkpointNs, checkpointId } = this.getConfigValues(config);
+    const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+
+    const checkpointRows = await this.resource().list(
+      checkpointId
+        ? Filters.AND(
+            Filters.EQ(r.threadIdField, threadId),
+            Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+            Filters.EQ(r.checkpointIdField, checkpointId),
+            Filters.EQ(r.rowKindField, "checkpoint"),
+          )
+        : Filters.AND(
+            Filters.EQ(r.threadIdField, threadId),
+            Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+            Filters.EQ(r.rowKindField, "checkpoint"),
+      ),
+      1,
+      undefined,
+      [{ field: r.checkpointIdField, direction: "desc" }],
+    );
+
+    const checkpointRow = checkpointRows[0];
+    if (!checkpointRow) {
+      return undefined;
+    }
+
+    const resolvedCheckpointId = String(checkpointRow[r.checkpointIdField]);
+
+    const writesRows = await this.resource().list(
+      Filters.AND(
+        Filters.EQ(r.threadIdField, threadId),
+        Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+        Filters.EQ(r.checkpointIdField, resolvedCheckpointId),
+        Filters.EQ(r.rowKindField, "writes"),
+      ),
+      undefined,
+      undefined,
+      [{ field: r.sequenceField, direction: "asc" }],
+    );
+
+    const pendingWrites: CheckpointPendingWrite[] = writesRows.flatMap((row) => {
+      const taskId = String(row[r.taskIdField] ?? "");
+      const write = this.deserialize<PendingWrite>(row[r.writesPayloadField]);
+      if (!write) {
+        return [];
+      }
+
+      const [channel, value] = write;
+      return [[taskId, channel, value]];
+    });
+
+    const parentCheckpointId = checkpointRow[r.parentCheckpointIdField]
+      ? String(checkpointRow[r.parentCheckpointIdField])
+      : null;
+
+    const tuple: CheckpointTuple = {
+      config: this.buildConfig(threadId, checkpointNs, resolvedCheckpointId),
+      checkpoint: this.deserialize<Checkpoint>(
+        checkpointRow[r.checkpointPayloadField],
+      ) as Checkpoint,
+      metadata: (this.deserialize<CheckpointMetadata>(
+        checkpointRow[r.metadataPayloadField],
+      ) ?? {}) as CheckpointMetadata,
+      parentConfig: parentCheckpointId
+        ? this.buildConfig(threadId, checkpointNs, parentCheckpointId)
+        : undefined,
+      pendingWrites,
+    };
+
+    return tuple;
+  }
+
+  async *list(
+    config: RunnableConfig,
+    options?: {
+      before?: RunnableConfig;
+      limit?: number;
+    },
+  ): AsyncGenerator<CheckpointTuple> {
+    const r = this.resourceConfig;
+    const { threadId, checkpointNs } = this.getConfigValues(config);
+    const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+    const beforeCheckpointId = options?.before
+      ? this.getConfigValues(options.before).checkpointId
+      : null;
+
+    const filters: Filters[] = [
+      Filters.EQ(r.rowKindField, "checkpoint"),
+      Filters.EQ(r.threadIdField, threadId),
+      Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+    ];
+
+    if (beforeCheckpointId) {
+      filters.push(Filters.LT(r.checkpointIdField, beforeCheckpointId));
+    }
+
+    const rows = await this.resource().list(
+      Filters.AND(...filters),
+      options?.limit,
+      undefined,
+      [{ field: r.checkpointIdField, direction: "desc" }],
+    );
+
+    for (const row of rows) {
+      const tuple = await this.getTuple(
+        this.buildConfig(
+          String(row[r.threadIdField]),
+          this.decodeCheckpointNamespace(row[r.checkpointNamespaceField]),
+          String(row[r.checkpointIdField]),
+        ),
+      );
+
+      if (tuple) {
+        yield tuple;
+      }
+    }
+  }
+
+  async deleteThread(threadId: string, checkpointNs = ""): Promise<void> {
+    const r = this.resourceConfig;
+    const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+
+    const rows = await this.resource().list(
+      Filters.AND(
+        Filters.EQ(r.threadIdField, threadId),
+        Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+      ),
+      undefined,
+      undefined,
+      [{ field: r.createdAtField, direction: "desc" }],
+    );
+
+    for (const row of rows) {
+      await this.adminforth
+        .resource(this.pluginOptions.checkpointResource!.resourceId)
+        .delete(row[r.idField]);
+    }
+  }
+}

package/agent/simpleAgent.ts

@@ -1,7 +1,7 @@
 import { createAgent, summarizationMiddleware } from "langchain";
 import { logger, type AdminUser, type CompletionAdapter } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import { MemorySaver, type Messages } from "@langchain/langgraph";
+import {type BaseCheckpointSaver, type Messages } from "@langchain/langgraph";
 import type { LLMResult } from "@langchain/core/outputs";
 import { z } from "zod";
 import { ChatOpenAI } from "@langchain/openai";
@@ -15,8 +15,6 @@ import { createOpenAiResponsesContinuationMiddleware } from "./middleware/openAi
 import type { ApiBasedTool } from "../apiBasedTools.js";
 import type { ToolCallEventSink } from "./toolCallEvents.js";
 
-const checkpointer = new MemorySaver();
-
 export const contextSchema = z.object({
   adminUser: z.custom<AdminUser>(),
   userTimeZone: z.string(),
@@ -36,6 +34,8 @@ type OpenAIBackedCompletionAdapter = CompletionAdapter & {
   };
 };
 
+type OpenAiReasoningConfig = Record<string, unknown>;
+
 type LlmOutputTokenUsage = {
   promptTokens?: unknown;
   completionTokens?: unknown;
@@ -178,7 +178,14 @@ export function createAgentChatModel(params: {
 
   const model = params.modelName ?? options.model ?? "gpt-5-nano";
   const baseURL = options.baseURL ?? options.baseUrl;
-  const reasoning = options.extraRequestBodyParameters?.reasoning;
+  const reasoning = options.extraRequestBodyParameters
+    ?.reasoning as OpenAiReasoningConfig | undefined;
+  const reasoningConfig = reasoning
+    ? {
+        ...reasoning,
+        summary: "auto",
+      }
+    : undefined;
 
   // @ts-ignore
   return new ChatOpenAI({
@@ -192,7 +199,7 @@ export function createAgentChatModel(params: {
 
     promptCacheRetention: "in_memory", 
 
-    ...(reasoning ? { reasoning } : {}),
+    ...(reasoningConfig ? { reasoning: reasoningConfig } : {}),
     ...(typeof options.timeoutMs === "number"
       ? { timeout: options.timeoutMs }
       : {}),
@@ -210,6 +217,7 @@ export async function callAgent(params: {
   name: string;
   model: ChatOpenAI;
   summaryModel: ChatOpenAI;
+  checkpointer?: BaseCheckpointSaver;
   messages: Messages;
   adminUser: AdminUser;
   apiBasedTools: Record<string, ApiBasedTool>;
@@ -224,6 +232,7 @@ export async function callAgent(params: {
     name,
     model,
     summaryModel,
+    checkpointer,
     messages,
     adminUser,
     apiBasedTools,

package/build.log

@@ -31,5 +31,5 @@ custom/skills/fetch_data/SKILL.md
 custom/skills/mutate_data/
 custom/skills/mutate_data/SKILL.md
 
-sent 185,223 bytes  received 432 bytes  371,310.00 bytes/sec
+sent 185,196 bytes  received 432 bytes  371,256.00 bytes/sec
 total size is 183,434  speedup is 0.99

package/dist/agent/checkpointer.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { BaseCheckpointSaver, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
+import { Filters } from "adminforth";
+const ROOT_CHECKPOINT_NAMESPACE = "__root__";
+export class AdminForthCheckpointSaver extends BaseCheckpointSaver {
+    constructor(adminforth, pluginOptions) {
+        super();
+        this.adminforth = adminforth;
+        this.pluginOptions = pluginOptions;
+    }
+    get resourceConfig() {
+        const resource = this.pluginOptions.checkpointResource;
+        if (!resource) {
+            throw new Error("checkpointResource is not configured");
+        }
+        return resource;
+    }
+    resource() {
+        return this.adminforth.resource(this.resourceConfig.resourceId);
+    }
+    serialize(value) {
+        if (value === undefined || value === null)
+            return null;
+        return JSON.stringify(value);
+    }
+    deserialize(value) {
+        if (value === undefined || value === null)
+            return null;
+        if (typeof value === "string") {
+            return JSON.parse(value);
+        }
+        return value;
+    }
+    now() {
+        return new Date().toISOString();
+    }
+    encodeCheckpointNamespace(checkpointNs) {
+        return checkpointNs === "" ? ROOT_CHECKPOINT_NAMESPACE : checkpointNs;
+    }
+    decodeCheckpointNamespace(checkpointNs) {
+        return checkpointNs === ROOT_CHECKPOINT_NAMESPACE ? "" : String(checkpointNs !== null && checkpointNs !== void 0 ? checkpointNs : "");
+    }
+    getConfigValues(config) {
+        var _a, _b, _c;
+        const configurable = ((_a = config.configurable) !== null && _a !== void 0 ? _a : {});
+        return {
+            threadId: String((_b = configurable.thread_id) !== null && _b !== void 0 ? _b : ""),
+            checkpointNs: String((_c = configurable.checkpoint_ns) !== null && _c !== void 0 ? _c : ""),
+            checkpointId: configurable.checkpoint_id
+                ? String(configurable.checkpoint_id)
+                : null,
+        };
+    }
+    buildConfig(threadId, checkpointNs, checkpointId) {
+        return {
+            configurable: {
+                thread_id: threadId,
+                checkpoint_ns: checkpointNs,
+                checkpoint_id: checkpointId,
+            },
+        };
+    }
+    buildCheckpointRowId(threadId, checkpointNs, checkpointId) {
+        return `cp:${threadId}:${checkpointNs}:${checkpointId}`;
+    }
+    buildWritesRowId(threadId, checkpointNs, checkpointId, taskId, seq) {
+        return `wr:${threadId}:${checkpointNs}:${checkpointId}:${taskId}:${seq}`;
+    }
+    getWriteIndex(channel, index) {
+        var _a;
+        return (_a = WRITES_IDX_MAP[channel]) !== null && _a !== void 0 ? _a : index;
+    }
+    isDuplicateCheckpointWriteError(error) {
+        return error instanceof Error && error.message.includes("UNIQUE constraint failed");
+    }
+    put(config, checkpoint, metadata, _newVersions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = this.resourceConfig;
+            const { threadId, checkpointNs } = this.getConfigValues(config);
+            const checkpointId = String(checkpoint.id);
+            const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+            const parentCheckpointId = this.getConfigValues(config).checkpointId;
+            const createdAt = this.now();
+            yield this.resource().create({
+                [r.idField]: this.buildCheckpointRowId(threadId, storedCheckpointNs, checkpointId),
+                [r.threadIdField]: threadId,
+                [r.checkpointNamespaceField]: storedCheckpointNs,
+                [r.checkpointIdField]: checkpointId,
+                [r.parentCheckpointIdField]: parentCheckpointId,
+                [r.rowKindField]: "checkpoint",
+                [r.taskIdField]: null,
+                [r.sequenceField]: 0,
+                [r.createdAtField]: createdAt,
+                [r.checkpointPayloadField]: this.serialize(checkpoint),
+                [r.metadataPayloadField]: this.serialize(metadata),
+                [r.writesPayloadField]: null,
+                [r.schemaVersionField]: 1,
+            });
+            return this.buildConfig(threadId, checkpointNs, checkpointId);
+        });
+    }
+    putWrites(config, writes, taskId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = this.resourceConfig;
+            const { threadId, checkpointNs, checkpointId } = this.getConfigValues(config);
+            const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+            if (!checkpointId) {
+                throw new Error("putWrites requires checkpoint_id in config");
+            }
+            const createdAt = this.now();
+            yield Promise.all(writes.map((_a, index_1) => __awaiter(this, [_a, index_1], void 0, function* ([channel, value], index) {
+                const writeIndex = this.getWriteIndex(channel, index);
+                try {
+                    yield this.resource().create({
+                        [r.idField]: this.buildWritesRowId(threadId, storedCheckpointNs, checkpointId, taskId, writeIndex),
+                        [r.threadIdField]: threadId,
+                        [r.checkpointNamespaceField]: storedCheckpointNs,
+                        [r.checkpointIdField]: checkpointId,
+                        [r.parentCheckpointIdField]: null,
+                        [r.rowKindField]: "writes",
+                        [r.taskIdField]: taskId,
+                        [r.sequenceField]: writeIndex,
+                        [r.createdAtField]: createdAt,
+                        [r.checkpointPayloadField]: null,
+                        [r.metadataPayloadField]: null,
+                        [r.writesPayloadField]: this.serialize([channel, value]),
+                        [r.schemaVersionField]: 1,
+                    });
+                }
+                catch (error) {
+                    if (!this.isDuplicateCheckpointWriteError(error)) {
+                        throw error;
+                    }
+                }
+            })));
+        });
+    }
+    getTuple(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const r = this.resourceConfig;
+            const { threadId, checkpointNs, checkpointId } = this.getConfigValues(config);
+            const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+            const checkpointRows = yield this.resource().list(checkpointId
+                ? Filters.AND(Filters.EQ(r.threadIdField, threadId), Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs), Filters.EQ(r.checkpointIdField, checkpointId), Filters.EQ(r.rowKindField, "checkpoint"))
+                : Filters.AND(Filters.EQ(r.threadIdField, threadId), Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs), Filters.EQ(r.rowKindField, "checkpoint")), 1, undefined, [{ field: r.checkpointIdField, direction: "desc" }]);
+            const checkpointRow = checkpointRows[0];
+            if (!checkpointRow) {
+                return undefined;
+            }
+            const resolvedCheckpointId = String(checkpointRow[r.checkpointIdField]);
+            const writesRows = yield this.resource().list(Filters.AND(Filters.EQ(r.threadIdField, threadId), Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs), Filters.EQ(r.checkpointIdField, resolvedCheckpointId), Filters.EQ(r.rowKindField, "writes")), undefined, undefined, [{ field: r.sequenceField, direction: "asc" }]);
+            const pendingWrites = writesRows.flatMap((row) => {
+                var _a;
+                const taskId = String((_a = row[r.taskIdField]) !== null && _a !== void 0 ? _a : "");
+                const write = this.deserialize(row[r.writesPayloadField]);
+                if (!write) {
+                    return [];
+                }
+                const [channel, value] = write;
+                return [[taskId, channel, value]];
+            });
+            const parentCheckpointId = checkpointRow[r.parentCheckpointIdField]
+                ? String(checkpointRow[r.parentCheckpointIdField])
+                : null;
+            const tuple = {
+                config: this.buildConfig(threadId, checkpointNs, resolvedCheckpointId),
+                checkpoint: this.deserialize(checkpointRow[r.checkpointPayloadField]),
+                metadata: ((_a = this.deserialize(checkpointRow[r.metadataPayloadField])) !== null && _a !== void 0 ? _a : {}),
+                parentConfig: parentCheckpointId
+                    ? this.buildConfig(threadId, checkpointNs, parentCheckpointId)
+                    : undefined,
+                pendingWrites,
+            };
+            return tuple;
+        });
+    }
+    list(config, options) {
+        return __asyncGenerator(this, arguments, function* list_1() {
+            const r = this.resourceConfig;
+            const { threadId, checkpointNs } = this.getConfigValues(config);
+            const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+            const beforeCheckpointId = (options === null || options === void 0 ? void 0 : options.before)
+                ? this.getConfigValues(options.before).checkpointId
+                : null;
+            const filters = [
+                Filters.EQ(r.rowKindField, "checkpoint"),
+                Filters.EQ(r.threadIdField, threadId),
+                Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs),
+            ];
+            if (beforeCheckpointId) {
+                filters.push(Filters.LT(r.checkpointIdField, beforeCheckpointId));
+            }
+            const rows = yield __await(this.resource().list(Filters.AND(...filters), options === null || options === void 0 ? void 0 : options.limit, undefined, [{ field: r.checkpointIdField, direction: "desc" }]));
+            for (const row of rows) {
+                const tuple = yield __await(this.getTuple(this.buildConfig(String(row[r.threadIdField]), this.decodeCheckpointNamespace(row[r.checkpointNamespaceField]), String(row[r.checkpointIdField]))));
+                if (tuple) {
+                    yield yield __await(tuple);
+                }
+            }
+        });
+    }
+    deleteThread(threadId_1) {
+        return __awaiter(this, arguments, void 0, function* (threadId, checkpointNs = "") {
+            const r = this.resourceConfig;
+            const storedCheckpointNs = this.encodeCheckpointNamespace(checkpointNs);
+            const rows = yield this.resource().list(Filters.AND(Filters.EQ(r.threadIdField, threadId), Filters.EQ(r.checkpointNamespaceField, storedCheckpointNs)), undefined, undefined, [{ field: r.createdAtField, direction: "desc" }]);
+            for (const row of rows) {
+                yield this.adminforth
+                    .resource(this.pluginOptions.checkpointResource.resourceId)
+                    .delete(row[r.idField]);
+            }
+        });
+    }
+}

package/dist/agent/simpleAgent.js

@@ -10,14 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { createAgent, summarizationMiddleware } from "langchain";
 import { logger } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import { MemorySaver } from "@langchain/langgraph";
 import { z } from "zod";
 import { ChatOpenAI } from "@langchain/openai";
 import { createAgentTools } from "./tools/index.js";
 import { createApiBasedToolsMiddleware } from "./middleware/apiBasedTools.js";
 import { createSequenceDebugMiddleware, } from "./middleware/sequenceDebug.js";
 import { createOpenAiResponsesContinuationMiddleware } from "./middleware/openAiResponsesContinuation.js";
-const checkpointer = new MemorySaver();
 export const contextSchema = z.object({
     adminUser: z.custom(),
     userTimeZone: z.string(),
@@ -113,8 +111,10 @@ export function createAgentChatModel(params) {
     const model = (_c = (_b = params.modelName) !== null && _b !== void 0 ? _b : options.model) !== null && _c !== void 0 ? _c : "gpt-5-nano";
     const baseURL = (_d = options.baseURL) !== null && _d !== void 0 ? _d : options.baseUrl;
     const reasoning = (_e = options.extraRequestBodyParameters) === null || _e === void 0 ? void 0 : _e.reasoning;
+    const reasoningConfig = reasoning
+        ? Object.assign(Object.assign({}, reasoning), { summary: "auto" }) : undefined;
     // @ts-ignore
-    return new ChatOpenAI(Object.assign(Object.assign(Object.assign({ apiKey: options.openAiApiKey, model, maxTokens: params.maxTokens, useResponsesApi: true, outputVersion: "v1", streaming: true, promptCacheKey: `adminforth-agent:${model}:system-v1:tools-v1`, promptCacheRetention: "in_memory" }, (reasoning ? { reasoning } : {})), (typeof options.timeoutMs === "number"
+    return new ChatOpenAI(Object.assign(Object.assign(Object.assign({ apiKey: options.openAiApiKey, model, maxTokens: params.maxTokens, useResponsesApi: true, outputVersion: "v1", streaming: true, promptCacheKey: `adminforth-agent:${model}:system-v1:tools-v1`, promptCacheRetention: "in_memory" }, (reasoningConfig ? { reasoning: reasoningConfig } : {})), (typeof options.timeoutMs === "number"
         ? { timeout: options.timeoutMs }
         : {})), (baseURL
         ? {
@@ -126,7 +126,7 @@ export function createAgentChatModel(params) {
 }
 export function callAgent(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { name, model, summaryModel, messages, adminUser, apiBasedTools, customComponentsDir, sessionId, turnId, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
+        const { name, model, summaryModel, checkpointer, messages, adminUser, apiBasedTools, customComponentsDir, sessionId, turnId, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
         const tools = yield createAgentTools(customComponentsDir, apiBasedTools);
         const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools);
         const openAiResponsesContinuationMiddleware = createOpenAiResponsesContinuationMiddleware();

package/dist/index.js

@@ -17,7 +17,9 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 import { AdminForthPlugin, logger, Filters, Sorts } from "adminforth";
 import { randomUUID } from 'crypto';
 import { HumanMessage, SystemMessage } from "langchain";
+import { MemorySaver } from "@langchain/langgraph";
 import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
+import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
 import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
 import { prepareApiBasedTools as buildApiBasedTools, } from './apiBasedTools.js';
 import { appendCustomSystemPrompt, buildAgentSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT, } from "./agent/systemPrompt.js";
@@ -88,9 +90,38 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
             }));
         });
     }
+    getModeModels(mode, maxTokens) {
+        const cachedModels = this.modelsByModeName.get(mode.name);
+        if (cachedModels) {
+            return cachedModels;
+        }
+        const models = {
+            model: createAgentChatModel({
+                adapter: mode.completionAdapter,
+                maxTokens,
+            }),
+            summaryModel: createAgentChatModel({
+                adapter: mode.completionAdapter,
+                maxTokens,
+            }),
+        };
+        this.modelsByModeName.set(mode.name, models);
+        return models;
+    }
+    getCheckpointer() {
+        if (this.checkpointer) {
+            return this.checkpointer;
+        }
+        this.checkpointer = this.options.checkpointResource
+            ? new AdminForthCheckpointSaver(this.adminforth, this.options)
+            : new MemorySaver();
+        return this.checkpointer;
+    }
     constructor(options) {
         super(options, import.meta.url);
         this.apiBasedTools = {};
+        this.checkpointer = null;
+        this.modelsByModeName = new Map();
         this.options = options;
         this.agentSystemPromptPromise = Promise.resolve(appendCustomSystemPrompt(DEFAULT_AGENT_SYSTEM_PROMPT, this.options.systemPrompt));
         this.shouldHaveSingleInstancePerWholeApp = () => false;
@@ -241,19 +272,13 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
                     });
                     const maxTokens = (_f = this.options.maxTokens) !== null && _f !== void 0 ? _f : 10000;
                     const selectedMode = (_g = this.options.modes.find((mode) => mode.name === body.mode)) !== null && _g !== void 0 ? _g : this.options.modes[0];
-                    const model = createAgentChatModel({
-                        adapter: selectedMode.completionAdapter,
-                        maxTokens,
-                    });
-                    const summaryModel = createAgentChatModel({
-                        adapter: selectedMode.completionAdapter,
-                        maxTokens,
-                    });
+                    const { model, summaryModel } = this.getModeModels(selectedMode, maxTokens);
                     const systemPrompt = yield this.agentSystemPromptPromise;
                     const stream = yield callAgent({
                         name: `adminforth-agent-${this.pluginInstanceId}`,
                         model,
                         summaryModel,
+                        checkpointer: this.getCheckpointer(),
                         messages: [
                             new SystemMessage(systemPrompt),
                             new HumanMessage(prompt),

package/index.ts

@@ -9,7 +9,9 @@ import { AdminForthPlugin, logger, Filters, Sorts } from "adminforth";
 import type { PluginOptions } from './types.js';
 import { randomUUID } from 'crypto';
 import { HumanMessage, SystemMessage } from "langchain";
+import { MemorySaver, type BaseCheckpointSaver } from "@langchain/langgraph";
 import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
+import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
 import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
 import {
   prepareApiBasedTools as buildApiBasedTools,
@@ -22,6 +24,7 @@ import {
 } from "./agent/systemPrompt.js";
 import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./agent/tools/index.js";
 import type { ToolCallEvent } from "./agent/toolCallEvents.js";
+import type { ChatOpenAI } from "@langchain/openai";
 
 function isAggregateErrorLike(
   error: unknown,
@@ -69,6 +72,14 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
   options: PluginOptions;
   apiBasedTools: Record<string, ApiBasedTool> = {};
   agentSystemPromptPromise: Promise<string>;
+  private checkpointer: BaseCheckpointSaver | null = null;
+  private readonly modelsByModeName = new Map<
+    string,
+    {
+      model: ChatOpenAI;
+      summaryModel: ChatOpenAI;
+    }
+  >();
 
   private async createNewTurn(sessionId: string, prompt: string, response?: string) {
     const turnId = randomUUID();
@@ -107,6 +118,43 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     }));
   }
 
+  private getModeModels(
+    mode: PluginOptions["modes"][number],
+    maxTokens: number,
+  ) {
+    const cachedModels = this.modelsByModeName.get(mode.name);
+
+    if (cachedModels) {
+      return cachedModels;
+    }
+
+    const models = {
+      model: createAgentChatModel({
+        adapter: mode.completionAdapter,
+        maxTokens,
+      }),
+      summaryModel: createAgentChatModel({
+        adapter: mode.completionAdapter,
+        maxTokens,
+      }),
+    };
+
+    this.modelsByModeName.set(mode.name, models);
+    return models;
+  }
+
+  private getCheckpointer() {
+    if (this.checkpointer) {
+      return this.checkpointer;
+    }
+
+    this.checkpointer = this.options.checkpointResource
+      ? new AdminForthCheckpointSaver(this.adminforth, this.options)
+      : new MemorySaver();
+
+    return this.checkpointer;
+  }
+
   constructor(options: PluginOptions) {
     super(options, import.meta.url);
     this.options = options;
@@ -278,20 +326,13 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
 
           const maxTokens = this.options.maxTokens ?? 10000;
           const selectedMode = this.options.modes.find((mode) => mode.name === body.mode) ?? this.options.modes[0];
-          const model = createAgentChatModel({
-            adapter: selectedMode.completionAdapter,
-            maxTokens,
-          });
-
-          const summaryModel = createAgentChatModel({
-            adapter: selectedMode.completionAdapter,
-            maxTokens,
-          });
+          const { model, summaryModel } = this.getModeModels(selectedMode, maxTokens);
           const systemPrompt = await this.agentSystemPromptPromise;
           const stream = await callAgent({
             name: `adminforth-agent-${this.pluginInstanceId}`,
             model,
             summaryModel,
+            checkpointer: this.getCheckpointer(),
             messages: [
               new SystemMessage(systemPrompt),
               new HumanMessage(prompt),
@@ -323,7 +364,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
               : Array.isArray(token?.content)
                 ? token.content
                 : [];
-
             const reasoningDelta = blocks
               .filter((b: any) => b?.type === "reasoning")
               .map((b: any) => String(b.reasoning ?? ""))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/agent",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -23,6 +23,7 @@
   "dependencies": {
     "@langchain/core": "^1.1.40",
     "@langchain/langgraph": "^1.2.8",
+    "@langchain/langgraph-checkpoint": "^1.0.1",
     "@langchain/openai": "^1.4.4",
     "adminforth": "2.27.0-next.47",
     "dayjs": "^1.11.20",

package/types.ts

@@ -24,6 +24,23 @@ interface ITurnResource {
   debugField?: string;
 }
 
+interface ICheckpointResource {
+  resourceId: string;
+  idField: string;
+  threadIdField: string;
+  checkpointNamespaceField: string;
+  checkpointIdField: string;
+  parentCheckpointIdField: string;
+  rowKindField: string;
+  taskIdField: string;
+  sequenceField: string;
+  createdAtField: string;
+  checkpointPayloadField: string;
+  metadataPayloadField: string;
+  writesPayloadField: string;
+  schemaVersionField: string;
+}
+
 export interface PluginOptions extends PluginsCommonOptions {
   /**
    * Optional placeholder examples to preload for the chat textarea.
@@ -75,4 +92,10 @@ export interface PluginOptions extends PluginsCommonOptions {
    * Makes chat sticky by default. By default this prop is false
    */
   stickByDefault?: boolean;
+
+  /**
+   * Optional resource configuration for a persistent LangGraph checkpointer.
+   * Falls back to an in-memory MemorySaver when omitted.
+   */
+  checkpointResource?: ICheckpointResource;
 }