@cloudbase/agent-adapter-langgraph 0.0.16 → 0.0.19

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import "./chunk-NSSMTXJJ.mjs";
-
 // src/agent.ts
 import {
   EventType,
@@ -8,8 +6,7 @@ import {
 import { Observable } from "rxjs";
 import {
   Annotation,
-  MessagesAnnotation,
-  Command
+  MessagesAnnotation
 } from "@langchain/langgraph";
 
 // src/util.ts
@@ -62,7 +59,6 @@ function convertJsonSchemaToZodSchema(jsonSchema, required) {
 // src/agent.ts
 import { noopLogger, isErrorWithCode } from "@cloudbase/agent-shared";
 var LangChainCallbackHandler;
-var observabilityLoadAttempted = false;
 var ClientPropertiesAnnotation = Annotation.Root({
   tools: Annotation
 });
@@ -87,45 +83,7 @@ var LanggraphAgent = class extends AbstractAgent {
     const { messages, runId, threadId } = input;
     const logger = this.logger.child?.({ runId, threadId }) ?? this.logger;
     logger.info?.("Run started");
-    if (!observabilityLoadAttempted && !this.observabilityCallback) {
-      observabilityLoadAttempted = true;
-      try {
-        logger.debug?.("Attempting to load observability...");
-        const obsModule = await import("./langchain-6EY35CAB.mjs");
-        LangChainCallbackHandler = obsModule.CallbackHandler;
-        if (LangChainCallbackHandler) {
-          this.observabilityCallback = new LangChainCallbackHandler({
-            adapterName: this.adapterName,
-            logger
-            // Reuse the run-specific logger with context
-          });
-          logger.debug?.("\u2713 Observability callback created");
-        }
-      } catch (e) {
-        logger.debug?.(
-          "\u2717 Observability not available:",
-          e instanceof Error ? e.message : String(e)
-        );
-      }
-    }
-    if (this.observabilityCallback && input.forwardedProps?.__agui_server_context) {
-      try {
-        const serverContextData = input.forwardedProps.__agui_server_context;
-        const serverSpanContext = {
-          traceId: serverContextData.traceId,
-          spanId: serverContextData.spanId,
-          traceFlags: serverContextData.traceFlags,
-          isRemote: false
-        };
-        this.observabilityCallback.setExternalParentContext(serverSpanContext);
-        logger.debug?.("\u2713 Server context restored:", {
-          traceId: serverSpanContext.traceId,
-          spanId: serverSpanContext.spanId
-        });
-      } catch (e) {
-        logger.debug?.("Failed to restore server context:", e);
-      }
-    }
+    await this.setupObservability(input, logger);
     const runStartedEvent = {
       type: EventType.RUN_STARTED,
       threadId,
@@ -133,11 +91,9 @@ var LanggraphAgent = class extends 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),
@@ -146,25 +102,21 @@ var LanggraphAgent = class extends 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 Command({
-      resume: JSON.stringify(input.forwardedProps?.resume?.payload)
-    }) : {
+    const langChainMessages = aguiMessagesToLangChain(messages, logger);
+    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(
@@ -197,7 +149,6 @@ var LanggraphAgent = class extends AbstractAgent {
         "Pre-populated handled tool call IDs from input messages"
       );
     }
-    let interrupt;
     let currentToolCall = null;
     let eventCount = 0;
     let toolCallCount = 0;
@@ -522,46 +473,17 @@ var LanggraphAgent = class extends 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: 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: 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: 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 },
@@ -587,9 +509,56 @@ var LanggraphAgent = class extends AbstractAgent {
     cloned.logger = logger;
     return cloned;
   }
+  /**
+   * Setup observability for agent execution.
+   * Lazy loads observability callback, restores server context from forwardedProps,
+   * and configures the callback for graph execution.
+   */
+  async setupObservability(input, logger) {
+    if (!LangChainCallbackHandler) {
+      try {
+        logger.debug?.("Attempting to load observability...");
+        const obsModule = await import("@cloudbase/agent-observability/langchain");
+        LangChainCallbackHandler = obsModule.CallbackHandler;
+        logger.debug?.("\u2713 Observability handler loaded");
+      } catch (e) {
+        logger.debug?.(
+          "\u2717 Observability not available:",
+          e instanceof Error ? e.message : String(e)
+        );
+      }
+    }
+    this.observabilityCallback = LangChainCallbackHandler ? new LangChainCallbackHandler({
+      adapterName: this.adapterName,
+      logger
+    }) : void 0;
+    if (this.observabilityCallback && input.forwardedProps?.__agui_server_context) {
+      try {
+        const serverContextData = input.forwardedProps.__agui_server_context;
+        const serverSpanContext = {
+          traceId: serverContextData.traceId,
+          spanId: serverContextData.spanId,
+          traceFlags: serverContextData.traceFlags,
+          isRemote: false
+        };
+        this.observabilityCallback.setExternalParentContext(serverSpanContext, {
+          threadId: input.threadId,
+          runId: input.runId
+        });
+        logger.debug?.("\u2713 Server context restored:", {
+          traceId: serverSpanContext.traceId,
+          spanId: serverSpanContext.spanId,
+          threadId: input.threadId,
+          runId: input.runId
+        });
+      } catch (e) {
+        logger.debug?.("Failed to restore server context:", e);
+      }
+    }
+  }
 };
-function aguiMessagesToLangChain(messages) {
-  return messages.map((message, index) => {
+function aguiMessagesToLangChain(messages, logger) {
+  return messages.map((message) => {
     switch (message.role) {
       case "user":
         if (typeof message.content === "string") {
@@ -600,10 +569,34 @@ function aguiMessagesToLangChain(messages) {
             type: "human"
           };
         } else {
+          const langChainContent = [];
+          for (const part of message.content) {
+            if (part.type === "text") {
+              langChainContent.push({ type: "text", text: part.text });
+            } else if (part.type === "binary") {
+              const imageUrl = convertBinaryToImageUrl(
+                part,
+                message.id,
+                logger
+              );
+              if (imageUrl) {
+                langChainContent.push({
+                  type: "image_url",
+                  image_url: { url: imageUrl }
+                });
+              }
+            }
+          }
+          if (langChainContent.length === 0) {
+            logger?.warn?.(
+              { messageId: message.id },
+              "User message content array resulted in empty LangChain content"
+            );
+          }
           return {
             id: message.id,
             role: message.role,
-            content: message.content.filter((m) => m.type === "text"),
+            content: langChainContent,
             type: "human"
           };
         }
@@ -648,6 +641,22 @@ function isValidJson(json) {
     return false;
   }
 }
+function convertBinaryToImageUrl(part, messageId, logger) {
+  if (!part.mimeType.startsWith("image/")) {
+    logger?.debug?.(
+      { mimeType: part.mimeType, messageId },
+      "Skipping non-image binary content"
+    );
+    return void 0;
+  }
+  if (part.url) {
+    return part.url;
+  }
+  if (part.data) {
+    return `data:${part.mimeType};base64,${part.data}`;
+  }
+  return void 0;
+}
 
 // src/checkpoint.ts
 import {
@@ -904,11 +913,368 @@ var TDAISaver = class extends BaseCheckpointSaver {
   }
 };
 
+// src/cloudbase-saver.ts
+import {
+  BaseCheckpointSaver as BaseCheckpointSaver3
+} from "@langchain/langgraph";
+
+// ../../../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
+import { load } from "@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 BaseCheckpointSaver3 {
+  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
 import {
-  BaseStore
+  BaseStore as BaseStore2
 } from "@langchain/langgraph";
-var TDAIStore = class extends BaseStore {
+var TDAIStore = class extends BaseStore2 {
   constructor(config) {
     super();
     this.isSetup = false;
@@ -1337,6 +1703,7 @@ import { noopLogger as noopLogger2, createConsoleLogger } from "@cloudbase/agent
 export {
   ClientPropertiesAnnotation,
   ClientStateAnnotation,
+  CloudBaseSaver,
   LanggraphAgent,
   TDAISaver,
   TDAIStore,