@cloudbase/agent-adapter-langgraph 1.0.1-alpha.21 → 1.0.1-alpha.23

package/dist/index.js

@@ -1360,7 +1360,7 @@ var init_esm2 = __esm({
   }
 });
 
-// ../../observability/dist/chunk-3MVJN6UI.mjs
+// ../../observability/dist/chunk-DUKIGNZF.mjs
 function createTraceAttributes({
   name,
   userId,
@@ -1405,19 +1405,20 @@ function createObservationAttributes(type, attributes) {
     modelParameters,
     usageDetails
   } = attributes;
+  const spanKind = OpenInferenceSpanKind[type.toUpperCase()] || "UNKNOWN";
   const otelAttributes = {
-    [SemanticConventions.OPENINFERENCE_SPAN_KIND]: type.toUpperCase(),
+    [SemanticConventions.OPENINFERENCE_SPAN_KIND]: spanKind,
     [OtelSpanAttributes.OBSERVATION_TYPE]: type,
     [OtelSpanAttributes.OBSERVATION_LEVEL]: level,
     [OtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
     [OtelSpanAttributes.VERSION]: version,
     // Use OpenInference input.value convention
     [SemanticConventions.INPUT_VALUE]: _serialize(input),
-    // Also set legacy agkit.observation.input for compatibility
+    // Also set observation.input for compatibility
     [OtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
     // Use OpenInference output.value convention
     [SemanticConventions.OUTPUT_VALUE]: _serialize(output),
-    // Also set legacy agkit.observation.output for compatibility
+    // Also set observation.output for compatibility
     [OtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output)
   };
   if (type === "llm") {
@@ -1938,9 +1939,9 @@ function observe(fn, options = {}) {
   Object.defineProperty(wrappedFunction, "length", { value: fn.length });
   return wrappedFunction;
 }
-var OtelSpanAttributes, init_constants, init_attributes, OBSERVABILITY_GLOBAL_SYMBOL, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION, init_tracerProvider, BaseObservation, ObservationSpan, ObservationLLM, ObservationEmbedding, ObservationAgent, ObservationTool, ObservationChain, ObservationRetriever, ObservationReranker, ObservationEvaluator, ObservationGuardrail, init_spanWrapper, src_exports, init_src;
-var init_chunk_3MVJN6UI = __esm({
-  "../../observability/dist/chunk-3MVJN6UI.mjs"() {
+var OBSERVABILITY_TRACER_NAME, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION, OtelSpanAttributes, init_constants, init_attributes, OBSERVABILITY_GLOBAL_SYMBOL, init_tracerProvider, BaseObservation, ObservationSpan, ObservationLLM, ObservationEmbedding, ObservationAgent, ObservationTool, ObservationChain, ObservationRetriever, ObservationReranker, ObservationEvaluator, ObservationGuardrail, init_spanWrapper, src_exports, init_src;
+var init_chunk_DUKIGNZF = __esm({
+  "../../observability/dist/chunk-DUKIGNZF.mjs"() {
     "use strict";
     init_chunk_NFEGQTCC();
     init_esm();
@@ -1951,34 +1952,37 @@ var init_chunk_3MVJN6UI = __esm({
     init_constants = __esm2({
       "src/core/constants.ts"() {
         "use strict";
+        OBSERVABILITY_TRACER_NAME = "agui-tracer";
+        OBSERVABILITY_SDK_NAME = "observability";
+        OBSERVABILITY_SDK_VERSION = "0.1.0";
         OtelSpanAttributes = {
           // OpenInference - re-export all standard conventions
           ...SemanticConventions,
-          // AG-Kit Trace attributes (non-standard)
+          // Trace attributes (non-standard)
           TRACE_NAME: "trace.name",
           TRACE_TAGS: "trace.tags",
           TRACE_PUBLIC: "trace.public",
           TRACE_METADATA: "trace.metadata",
           TRACE_INPUT: "trace.input",
           TRACE_OUTPUT: "trace.output",
-          // AG-Kit Observation attributes (non-standard)
+          // Observation attributes (non-standard)
           OBSERVATION_TYPE: "observation.type",
           OBSERVATION_LEVEL: "observation.level",
           OBSERVATION_STATUS_MESSAGE: "observation.status_message",
           OBSERVATION_INPUT: "observation.input",
           OBSERVATION_OUTPUT: "observation.output",
           OBSERVATION_METADATA: "observation.metadata",
-          // AG-Kit LLM-specific (non-standard)
+          // LLM-specific (non-standard)
           LLM_COMPLETION_START_TIME: "llm.completion_start_time",
           LLM_MODEL_PARAMETERS: "llm.model_parameters",
           LLM_USAGE_DETAILS: "llm.usage_details",
           LLM_COST_DETAILS: "llm.cost_details",
-          // AG-Kit Retriever-specific (non-standard)
+          // Retriever-specific (non-standard)
           RETRIEVER_NAME: "retriever.name",
           RETRIEVER_QUERY: "retriever.query",
           RETRIEVER_INDEX_ID: "retriever.index_id",
           RETRIEVER_TOP_K: "retriever.top_k",
-          // AG-Kit General (non-standard)
+          // General (non-standard)
           ENVIRONMENT: "environment",
           RELEASE: "release",
           VERSION: "version"
@@ -1994,9 +1998,8 @@ var init_chunk_3MVJN6UI = __esm({
     init_tracerProvider = __esm2({
       "src/core/tracerProvider.ts"() {
         "use strict";
+        init_constants();
         OBSERVABILITY_GLOBAL_SYMBOL = /* @__PURE__ */ Symbol.for("observability");
-        OBSERVABILITY_SDK_NAME = "ag-kit-observability";
-        OBSERVABILITY_SDK_VERSION = "0.1.0";
       }
     });
     init_spanWrapper = __esm2({
@@ -2024,7 +2027,7 @@ var init_chunk_3MVJN6UI = __esm({
               );
             }
           }
-          /** Gets the AG-Kit OpenTelemetry tracer instance */
+          /** Gets the OpenTelemetry tracer instance */
           get tracer() {
             return getTracer();
           }
@@ -2181,6 +2184,9 @@ var init_chunk_3MVJN6UI = __esm({
     });
     src_exports = {};
     __export2(src_exports, {
+      OBSERVABILITY_SDK_NAME: () => OBSERVABILITY_SDK_NAME,
+      OBSERVABILITY_SDK_VERSION: () => OBSERVABILITY_SDK_VERSION,
+      OBSERVABILITY_TRACER_NAME: () => OBSERVABILITY_TRACER_NAME,
       ObservationAgent: () => ObservationAgent,
       ObservationChain: () => ObservationChain,
       ObservationEmbedding: () => ObservationEmbedding,
@@ -2211,6 +2217,7 @@ var init_chunk_3MVJN6UI = __esm({
         init_tracerProvider();
         init_attributes();
         init_tracerProvider();
+        init_constants();
       }
     });
   }
@@ -2225,7 +2232,7 @@ var import_base, import_messages, import_agent_shared, CallbackHandler;
 var init_langchain = __esm({
   "../../observability/dist/langchain.mjs"() {
     "use strict";
-    init_chunk_3MVJN6UI();
+    init_chunk_DUKIGNZF();
     init_chunk_NFEGQTCC();
     import_base = require("@langchain/core/callbacks/base");
     import_messages = require("@langchain/core/messages");
@@ -2776,6 +2783,7 @@ var index_exports = {};
 __export(index_exports, {
   ClientPropertiesAnnotation: () => ClientPropertiesAnnotation,
   ClientStateAnnotation: () => ClientStateAnnotation,
+  CloudBaseSaver: () => CloudBaseSaver,
   LanggraphAgent: () => LanggraphAgent,
   TDAISaver: () => TDAISaver,
   TDAIStore: () => TDAIStore,
@@ -2910,11 +2918,9 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
     };
     logger.trace?.({ aguiEvent: runStartedEvent }, "Emitting AGUI event");
     subscriber.next(runStartedEvent);
-    const isResume = !!input.forwardedProps?.resume;
     const lastUserMessage = messages.filter((m) => m.role === "user").pop();
     logger.debug?.(
       {
-        isResume,
         messageCount: messages.length,
         toolCount: input.tools?.length ?? 0,
         tools: input.tools?.map((t) => t.name),
@@ -2923,25 +2929,21 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
       "Preparing stream input"
     );
     logger.trace?.({ messages, tools: input.tools }, "Full input messages");
-    const langChainMessages = isResume ? void 0 : aguiMessagesToLangChain(messages);
-    if (langChainMessages) {
-      logger.trace?.(
-        {
-          langChainMessages,
-          messageCount: langChainMessages.length,
-          messageTypes: langChainMessages.map((m) => ({
-            type: m.type,
-            id: m.id,
-            hasToolCalls: "tool_calls" in m && Array.isArray(m.tool_calls) && m.tool_calls.length > 0,
-            toolCallId: "tool_call_id" in m ? m.tool_call_id : void 0
-          }))
-        },
-        "Converted LangGraph messages"
-      );
-    }
-    const streamEventInput = isResume ? new import_langgraph.Command({
-      resume: JSON.stringify(input.forwardedProps?.resume?.payload)
-    }) : {
+    const langChainMessages = aguiMessagesToLangChain(messages);
+    logger.trace?.(
+      {
+        langChainMessages,
+        messageCount: langChainMessages.length,
+        messageTypes: langChainMessages.map((m) => ({
+          type: m.type,
+          id: m.id,
+          hasToolCalls: "tool_calls" in m && Array.isArray(m.tool_calls) && m.tool_calls.length > 0,
+          toolCallId: "tool_call_id" in m ? m.tool_call_id : void 0
+        }))
+      },
+      "Converted LangGraph messages"
+    );
+    const streamEventInput = {
       messages: langChainMessages,
       client: {
         tools: convertActionsToDynamicStructuredTools(
@@ -2974,7 +2976,6 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
         "Pre-populated handled tool call IDs from input messages"
       );
     }
-    let interrupt;
     let currentToolCall = null;
     let eventCount = 0;
     let toolCallCount = 0;
@@ -3299,46 +3300,17 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
               "State update with messages"
             );
           }
-          if (chunk?.__interrupt__ && Array.isArray(chunk.__interrupt__) && chunk.__interrupt__.length > 0) {
-            const rawInterrupt = chunk.__interrupt__[0];
-            logger.debug?.(
-              { interruptId: rawInterrupt.id },
-              "Interrupt received"
-            );
-            interrupt = {
-              id: rawInterrupt.id,
-              // TODO: replace with actual reason
-              reason: "agent requested interrupt",
-              payload: rawInterrupt.value
-            };
-          }
         }
       }
       const stats = { eventCount, toolCallCount, textChunkCount };
-      if (interrupt) {
-        const runFinishedEvent = {
-          type: import_client.EventType.RUN_FINISHED,
-          threadId,
-          runId,
-          outcome: "interrupt",
-          interrupt
-        };
-        logger.info?.(
-          { outcome: "interrupt", interruptId: interrupt.id, ...stats },
-          "Run finished with interrupt"
-        );
-        logger.trace?.({ aguiEvent: runFinishedEvent }, "Emitting AGUI event");
-        subscriber.next(runFinishedEvent);
-      } else {
-        const runFinishedEvent = {
-          type: import_client.EventType.RUN_FINISHED,
-          threadId,
-          runId
-        };
-        logger.info?.({ outcome: "complete", ...stats }, "Run finished");
-        logger.trace?.({ aguiEvent: runFinishedEvent }, "Emitting AGUI event");
-        subscriber.next(runFinishedEvent);
-      }
+      const runFinishedEvent = {
+        type: import_client.EventType.RUN_FINISHED,
+        threadId,
+        runId
+      };
+      logger.info?.({ outcome: "complete", ...stats }, "Run finished");
+      logger.trace?.({ aguiEvent: runFinishedEvent }, "Emitting AGUI event");
+      subscriber.next(runFinishedEvent);
     } catch (error) {
       logger.error?.(
         { err: error, eventCount, toolCallCount, textChunkCount },
@@ -3366,7 +3338,7 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
   }
 };
 function aguiMessagesToLangChain(messages) {
-  return messages.map((message, index) => {
+  return messages.map((message) => {
     switch (message.role) {
       case "user":
         if (typeof message.content === "string") {
@@ -3676,9 +3648,364 @@ var TDAISaver = class extends import_langgraph2.BaseCheckpointSaver {
   }
 };
 
-// src/store/tdai-store.ts
+// src/cloudbase-saver.ts
 var import_langgraph3 = require("@langchain/langgraph");
-var TDAIStore = class extends import_langgraph3.BaseStore {
+
+// ../../../node_modules/.pnpm/@langchain+langgraph-checkpoint@1.0.0_@langchain+core@1.1.16_@opentelemetry+api@1.9.0_@_6d00458ac2f8320fcf28949c4b5d31a3/node_modules/@langchain/langgraph-checkpoint/dist/serde/types.js
+var ERROR = "__error__";
+var SCHEDULED = "__scheduled__";
+var INTERRUPT = "__interrupt__";
+var RESUME = "__resume__";
+
+// ../../../node_modules/.pnpm/@langchain+langgraph-checkpoint@1.0.0_@langchain+core@1.1.16_@opentelemetry+api@1.9.0_@_6d00458ac2f8320fcf28949c4b5d31a3/node_modules/@langchain/langgraph-checkpoint/dist/serde/jsonplus.js
+var import_load = require("@langchain/core/load");
+
+// ../../../node_modules/.pnpm/@langchain+langgraph-checkpoint@1.0.0_@langchain+core@1.1.16_@opentelemetry+api@1.9.0_@_6d00458ac2f8320fcf28949c4b5d31a3/node_modules/@langchain/langgraph-checkpoint/dist/base.js
+function deepCopy(obj) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  const newObj = Array.isArray(obj) ? [] : {};
+  for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = deepCopy(obj[key]);
+  return newObj;
+}
+function copyCheckpoint(checkpoint) {
+  return {
+    v: checkpoint.v,
+    id: checkpoint.id,
+    ts: checkpoint.ts,
+    channel_values: { ...checkpoint.channel_values },
+    channel_versions: { ...checkpoint.channel_versions },
+    versions_seen: deepCopy(checkpoint.versions_seen)
+  };
+}
+var WRITES_IDX_MAP = {
+  [ERROR]: -1,
+  [SCHEDULED]: -2,
+  [INTERRUPT]: -3,
+  [RESUME]: -4
+};
+
+// src/cloudbase-saver.ts
+var CloudBaseSaver = class extends import_langgraph3.BaseCheckpointSaver {
+  constructor(config) {
+    super();
+    this.db = config.db;
+    this.userId = config.userId;
+    this.agentId = config.agentId ?? "default";
+    this.checkpointsCollection = config.checkpointsCollection ?? "checkpoints";
+    this.writesCollection = config.writesCollection ?? "checkpoint_writes";
+  }
+  /**
+   * Setup the required collections in CloudBase.
+   * Call this once before using the saver. Safe to call multiple times.
+   */
+  async setup() {
+    const createIfNotExists = async (name) => {
+      try {
+        await this.db.createCollection(name);
+      } catch (e) {
+        const error = e;
+        if (error.code !== "DATABASE_COLLECTION_ALREADY_EXIST") {
+          throw e;
+        }
+      }
+    };
+    await Promise.all([
+      createIfNotExists(this.checkpointsCollection),
+      createIfNotExists(this.writesCollection)
+    ]);
+  }
+  /**
+   * Serialize data to JSON object using serde.
+   * CloudBase is a document database, so we store JSON directly instead of Base64.
+   * Binary data (Uint8Array) is not supported - fail early if encountered.
+   */
+  async serialize(data) {
+    const [type, bytes] = await this.serde.dumpsTyped(data);
+    if (type === "bytes") {
+      throw new Error(
+        "Binary data (Uint8Array) is not supported in CloudBaseSaver. CloudBase is a document database that only supports JSON-serializable data."
+      );
+    }
+    const jsonString = new TextDecoder().decode(bytes);
+    return JSON.parse(jsonString);
+  }
+  /**
+   * Deserialize JSON object back to data using serde.
+   */
+  async deserialize(data) {
+    const jsonString = JSON.stringify(data);
+    const bytes = new TextEncoder().encode(jsonString);
+    return this.serde.loadsTyped("json", bytes);
+  }
+  /**
+   * Retrieves a checkpoint from CloudBase based on the provided config.
+   */
+  async getTuple(config) {
+    const {
+      thread_id,
+      checkpoint_ns = "",
+      checkpoint_id
+    } = config.configurable ?? {};
+    if (!thread_id) {
+      return void 0;
+    }
+    const query = {
+      _openid: this.userId,
+      agent_id: this.agentId,
+      thread_id,
+      checkpoint_ns
+    };
+    if (checkpoint_id) {
+      query.checkpoint_id = checkpoint_id;
+    }
+    const { data: docs } = await this.db.collection(this.checkpointsCollection).where(query).orderBy("checkpoint_id", "desc").limit(1).get();
+    if (docs.length === 0) {
+      return void 0;
+    }
+    const doc = docs[0];
+    const checkpointId = doc.checkpoint_id;
+    const checkpoint = await this.deserialize(doc.checkpoint);
+    const metadata = await this.deserialize(
+      doc.metadata
+    );
+    const writeDocs = [];
+    let writeSkip = 0;
+    const writePageSize = 100;
+    while (true) {
+      const { data: docs2 } = await this.db.collection(this.writesCollection).where({
+        _openid: this.userId,
+        agent_id: this.agentId,
+        thread_id,
+        checkpoint_ns,
+        checkpoint_id: checkpointId
+      }).orderBy("idx", "asc").skip(writeSkip).limit(writePageSize).get();
+      writeDocs.push(...docs2);
+      if (docs2.length < writePageSize) break;
+      writeSkip += docs2.length;
+    }
+    const pendingWrites = await Promise.all(
+      writeDocs.map(async (writeDoc) => {
+        const value = await this.deserialize(writeDoc.value);
+        return [
+          writeDoc.task_id,
+          writeDoc.channel,
+          value
+        ];
+      })
+    );
+    return {
+      config: {
+        configurable: {
+          thread_id,
+          checkpoint_ns,
+          checkpoint_id: checkpointId
+        }
+      },
+      checkpoint,
+      metadata,
+      pendingWrites,
+      parentConfig: doc.parent_checkpoint_id ? {
+        configurable: {
+          thread_id,
+          checkpoint_ns,
+          checkpoint_id: doc.parent_checkpoint_id
+        }
+      } : void 0
+    };
+  }
+  /**
+   * List checkpoints from CloudBase, ordered by checkpoint_id descending.
+   */
+  async *list(config, options) {
+    const { limit, before, filter } = options ?? {};
+    const thread_id = config.configurable?.thread_id;
+    const checkpoint_ns = config.configurable?.checkpoint_ns;
+    if (!thread_id) {
+      throw new Error("Thread ID is required");
+    }
+    const _ = this.db.command;
+    const query = {
+      _openid: this.userId,
+      agent_id: this.agentId,
+      thread_id
+    };
+    if (checkpoint_ns !== void 0 && checkpoint_ns !== null) {
+      query.checkpoint_ns = checkpoint_ns;
+    }
+    if (before?.configurable?.checkpoint_id) {
+      query.checkpoint_id = _.lt(before.configurable.checkpoint_id);
+    }
+    const validCheckpointMetadataKeys = ["source", "step", "writes", "parents"];
+    if (filter) {
+      for (const [key, value] of Object.entries(filter)) {
+        if (value !== void 0 && validCheckpointMetadataKeys.includes(key)) {
+          query[`metadata.${key}`] = value;
+        }
+      }
+    }
+    let skip = 0;
+    const pageSize = Math.min(limit ?? 100, 100);
+    let yielded = 0;
+    while (true) {
+      const { data: docs } = await this.db.collection(this.checkpointsCollection).where(query).orderBy("checkpoint_id", "desc").skip(skip).limit(pageSize).get();
+      if (docs.length === 0) break;
+      for (const doc of docs) {
+        const checkpoint = await this.deserialize(
+          doc.checkpoint
+        );
+        const metadata = await this.deserialize(
+          doc.metadata
+        );
+        const writeDocs = [];
+        let writeSkip = 0;
+        const writePageSize = 100;
+        while (true) {
+          const { data: pageWriteDocs } = await this.db.collection(this.writesCollection).where({
+            _openid: this.userId,
+            agent_id: this.agentId,
+            thread_id: doc.thread_id,
+            checkpoint_ns: doc.checkpoint_ns,
+            checkpoint_id: doc.checkpoint_id
+          }).orderBy("idx", "asc").skip(writeSkip).limit(writePageSize).get();
+          writeDocs.push(...pageWriteDocs);
+          if (pageWriteDocs.length < writePageSize) break;
+          writeSkip += pageWriteDocs.length;
+        }
+        const pendingWrites = await Promise.all(
+          writeDocs.map(async (writeDoc) => {
+            const value = await this.deserialize(writeDoc.value);
+            return [
+              writeDoc.task_id,
+              writeDoc.channel,
+              value
+            ];
+          })
+        );
+        yield {
+          config: {
+            configurable: {
+              thread_id: doc.thread_id,
+              checkpoint_ns: doc.checkpoint_ns,
+              checkpoint_id: doc.checkpoint_id
+            }
+          },
+          checkpoint,
+          metadata,
+          pendingWrites,
+          parentConfig: doc.parent_checkpoint_id ? {
+            configurable: {
+              thread_id: doc.thread_id,
+              checkpoint_ns: doc.checkpoint_ns,
+              checkpoint_id: doc.parent_checkpoint_id
+            }
+          } : void 0
+        };
+        yielded++;
+        if (limit && yielded >= limit) return;
+      }
+      skip += docs.length;
+      if (docs.length < pageSize) break;
+    }
+  }
+  /**
+   * Save a checkpoint to CloudBase.
+   */
+  async put(config, checkpoint, metadata) {
+    if (!config.configurable) {
+      throw new Error("Empty configuration supplied.");
+    }
+    const thread_id = config.configurable.thread_id;
+    const checkpoint_ns = config.configurable.checkpoint_ns ?? "";
+    const checkpoint_id = checkpoint.id;
+    if (!thread_id) {
+      throw new Error(
+        'Missing "thread_id" field in passed "config.configurable".'
+      );
+    }
+    const preparedCheckpoint = copyCheckpoint(checkpoint);
+    const serializedCheckpoint = await this.serialize(preparedCheckpoint);
+    const serializedMetadata = await this.serialize(metadata);
+    const doc = {
+      _openid: this.userId,
+      agent_id: this.agentId,
+      thread_id,
+      checkpoint_ns,
+      checkpoint_id,
+      parent_checkpoint_id: config.configurable.checkpoint_id ?? null,
+      checkpoint: serializedCheckpoint,
+      metadata: serializedMetadata,
+      created_at: /* @__PURE__ */ new Date()
+    };
+    const docId = `${this.agentId}:${thread_id}:${checkpoint_ns}:${checkpoint_id}`;
+    await this.db.collection(this.checkpointsCollection).doc(docId).set(doc);
+    return {
+      configurable: {
+        thread_id,
+        checkpoint_ns,
+        checkpoint_id
+      }
+    };
+  }
+  /**
+   * Save intermediate writes to CloudBase.
+   */
+  async putWrites(config, writes, taskId) {
+    if (!config.configurable) {
+      throw new Error("Empty configuration supplied.");
+    }
+    if (!config.configurable.thread_id) {
+      throw new Error("Missing thread_id field in config.configurable.");
+    }
+    if (!config.configurable.checkpoint_id) {
+      throw new Error("Missing checkpoint_id field in config.configurable.");
+    }
+    const thread_id = config.configurable.thread_id;
+    const checkpoint_ns = config.configurable.checkpoint_ns ?? "";
+    const checkpoint_id = config.configurable.checkpoint_id;
+    const serializedWrites = await Promise.all(
+      writes.map(async ([channel, value], idx) => ({
+        channel,
+        value: await this.serialize(value),
+        idx,
+        docId: `${this.agentId}:${thread_id}:${checkpoint_ns}:${checkpoint_id}:${taskId}:${idx}`
+      }))
+    );
+    await this.db.runTransaction(async (transaction) => {
+      for (const { channel, value, idx, docId } of serializedWrites) {
+        await transaction.collection(this.writesCollection).doc(docId).set({
+          _openid: this.userId,
+          agent_id: this.agentId,
+          thread_id,
+          checkpoint_ns,
+          checkpoint_id,
+          task_id: taskId,
+          idx,
+          channel,
+          value
+        });
+      }
+    });
+  }
+  /**
+   * Delete all checkpoints and writes for a thread.
+   */
+  async deleteThread(threadId) {
+    await this.db.collection(this.checkpointsCollection).where({
+      _openid: this.userId,
+      agent_id: this.agentId,
+      thread_id: threadId
+    }).remove();
+    await this.db.collection(this.writesCollection).where({
+      _openid: this.userId,
+      agent_id: this.agentId,
+      thread_id: threadId
+    }).remove();
+  }
+};
+
+// src/store/tdai-store.ts
+var import_langgraph4 = require("@langchain/langgraph");
+var TDAIStore = class extends import_langgraph4.BaseStore {
   constructor(config) {
     super();
     this.isSetup = false;
@@ -4108,6 +4435,7 @@ var import_agent_shared3 = require("@cloudbase/agent-shared");
 0 && (module.exports = {
   ClientPropertiesAnnotation,
   ClientStateAnnotation,
+  CloudBaseSaver,
   LanggraphAgent,
   TDAISaver,
   TDAIStore,