@cloudbase/agent-adapter-langgraph 0.0.11 → 0.0.13

package/dist/index.js

@@ -34,7 +34,9 @@ __export(index_exports, {
   ClientStateAnnotation: () => ClientStateAnnotation,
   LanggraphAgent: () => LanggraphAgent,
   TDAISaver: () => TDAISaver,
-  TDAIStore: () => TDAIStore
+  TDAIStore: () => TDAIStore,
+  createConsoleLogger: () => import_agent_shared2.createConsoleLogger,
+  noopLogger: () => import_agent_shared2.noopLogger
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -91,6 +93,7 @@ function convertJsonSchemaToZodSchema(jsonSchema, required) {
 }
 
 // src/agent.ts
+var import_agent_shared = require("@cloudbase/agent-shared");
 var ClientPropertiesAnnotation = import_langgraph.Annotation.Root({
   tools: import_langgraph.Annotation
 });
@@ -102,6 +105,8 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
   constructor(agentConfig) {
     super(agentConfig);
     this.compiledWorkflow = agentConfig.compiledWorkflow;
+    const baseLogger = agentConfig.logger ?? import_agent_shared.noopLogger;
+    this.logger = baseLogger.child?.({ component: "langgraph-agent" }) ?? baseLogger;
   }
   run(input) {
     return new import_rxjs.Observable((subscriber) => {
@@ -110,12 +115,29 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
   }
   async _run(subscriber, input) {
     const { messages, runId, threadId } = input;
-    subscriber.next({
+    const logger = this.logger.child?.({ runId, threadId }) ?? this.logger;
+    logger.info?.("Run started");
+    const runStartedEvent = {
       type: import_client.EventType.RUN_STARTED,
       threadId,
       runId
-    });
-    const streamEventInput = input.forwardedProps?.resume ? new import_langgraph.Command({
+    };
+    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),
+        lastUserMessage: typeof lastUserMessage?.content === "string" ? lastUserMessage.content.slice(0, 200) : void 0
+      },
+      "Preparing stream input"
+    );
+    logger.trace?.({ messages, tools: input.tools }, "Full input messages");
+    const streamEventInput = isResume ? new import_langgraph.Command({
       resume: JSON.stringify(input.forwardedProps?.resume?.payload)
     }) : {
       messages: aguiMessagesToLangChain(messages),
@@ -135,6 +157,7 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
         thread_id: threadId
       }
     });
+    logger.debug?.("Stream created, starting event processing");
     const chatModelRuns = [];
     const handledToolCallIds = /* @__PURE__ */ new Set();
     for (const msg of messages) {
@@ -142,202 +165,375 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
         handledToolCallIds.add(msg.toolCallId);
       }
     }
+    if (handledToolCallIds.size > 0) {
+      logger.debug?.(
+        { count: handledToolCallIds.size },
+        "Pre-populated handled tool call IDs from input messages"
+      );
+    }
     let interrupt;
     let currentToolCall = null;
-    for await (const event of stream) {
-      if (event.event.startsWith("ChannelWrite<")) {
-        continue;
-      }
-      if (event.event === "on_chat_model_start") {
-        chatModelRuns.push({ runId: event.run_id });
-        continue;
-      }
-      if (event.event === "on_chat_model_stream") {
-        let chatModelRun = chatModelRuns.find(
-          (run) => run.runId === event.run_id
+    let eventCount = 0;
+    let toolCallCount = 0;
+    let textChunkCount = 0;
+    try {
+      for await (const event of stream) {
+        eventCount++;
+        logger.trace?.(
+          { eventType: event.event, eventCount, langGraphEvent: event },
+          "Processing stream event"
         );
-        if (!chatModelRun) {
-          subscriber.next({
-            type: import_client.EventType.RUN_ERROR,
-            message: `Received a message from an unknown chat model run. Run Id: ${event.run_id}`
-          });
+        if (event.event.startsWith("ChannelWrite<")) {
           continue;
         }
-        const chunkId = event.data.chunk.id;
-        if (!chatModelRun.messageId) {
-          chatModelRun.messageId = chunkId;
-          subscriber.next({
-            messageId: chunkId,
-            type: import_client.EventType.TEXT_MESSAGE_START,
-            role: "assistant"
-          });
-        } else if (chatModelRun.messageId !== chunkId) {
-          subscriber.next({
-            type: import_client.EventType.RUN_ERROR,
-            message: `Received a message of unknown message id from current run. Run Id: ${event.run_id} Message Id from current run: ${chatModelRun.messageId} Message Id from received message: ${chunkId}`
-          });
+        if (event.event === "on_chat_model_start") {
+          logger.debug?.(
+            { chatModelRunId: event.run_id },
+            "Chat model started"
+          );
+          chatModelRuns.push({ runId: event.run_id });
           continue;
         }
-        if (Array.isArray(event.data.chunk?.tool_call_chunks) && event.data.chunk?.tool_call_chunks?.length > 0) {
-          const parentMessageId = chatModelRun.messageId;
-          event.data.chunk.tool_call_chunks.map((x) => ({
-            ...x,
-            args: typeof x.args === "string" ? x.args : x.args ? JSON.stringify(x.args) : ""
-          })).forEach((toolCall) => {
-            if (currentToolCall) {
-              if (toolCall.id && currentToolCall.id !== toolCall.id) {
-                subscriber.next({
-                  toolCallId: currentToolCall.id,
-                  type: import_client.EventType.TOOL_CALL_END
-                });
-                if (toolCall.name && toolCall.id) {
-                  currentToolCall = toolCall;
-                  subscriber.next({
+        if (event.event === "on_chat_model_stream") {
+          const chatModelRun = chatModelRuns.find(
+            (run) => run.runId === event.run_id
+          );
+          if (!chatModelRun) {
+            logger.warn?.(
+              { chatModelRunId: event.run_id },
+              "Received message from unknown chat model run"
+            );
+            subscriber.next({
+              type: import_client.EventType.RUN_ERROR,
+              message: `Received a message from an unknown chat model run. Run Id: ${event.run_id}`
+            });
+            continue;
+          }
+          const chunkId = event.data.chunk.id;
+          if (!chatModelRun.messageId) {
+            chatModelRun.messageId = chunkId;
+            const textStartEvent = {
+              messageId: chunkId,
+              type: import_client.EventType.TEXT_MESSAGE_START,
+              role: "assistant"
+            };
+            logger.debug?.({ messageId: chunkId }, "Text message started");
+            logger.trace?.(
+              { aguiEvent: textStartEvent },
+              "Emitting AGUI event"
+            );
+            subscriber.next(textStartEvent);
+          } else if (chatModelRun.messageId !== chunkId) {
+            logger.warn?.(
+              {
+                expectedMessageId: chatModelRun.messageId,
+                receivedMessageId: chunkId,
+                chatModelRunId: event.run_id
+              },
+              "Received message with unexpected ID"
+            );
+            subscriber.next({
+              type: import_client.EventType.RUN_ERROR,
+              message: `Received a message of unknown message id from current run. Run Id: ${event.run_id} Message Id from current run: ${chatModelRun.messageId} Message Id from received message: ${chunkId}`
+            });
+            continue;
+          }
+          if (Array.isArray(event.data.chunk?.tool_call_chunks) && event.data.chunk?.tool_call_chunks?.length > 0) {
+            const parentMessageId = chatModelRun.messageId;
+            event.data.chunk.tool_call_chunks.map((x) => ({
+              ...x,
+              args: typeof x.args === "string" ? x.args : x.args ? JSON.stringify(x.args) : ""
+            })).forEach((toolCall) => {
+              if (currentToolCall) {
+                if (toolCall.id && currentToolCall.id !== toolCall.id) {
+                  const toolEndEvent = {
                     toolCallId: currentToolCall.id,
-                    toolCallName: currentToolCall.name,
-                    parentMessageId,
-                    type: import_client.EventType.TOOL_CALL_START
-                  });
-                  if (currentToolCall.args) {
-                    subscriber.next({
+                    type: import_client.EventType.TOOL_CALL_END
+                  };
+                  logger.debug?.(
+                    {
+                      toolCallId: currentToolCall.id,
+                      toolCallName: currentToolCall.name
+                    },
+                    "Tool call ended"
+                  );
+                  logger.trace?.(
+                    { aguiEvent: toolEndEvent },
+                    "Emitting AGUI event"
+                  );
+                  subscriber.next(toolEndEvent);
+                  if (toolCall.name && toolCall.id) {
+                    currentToolCall = toolCall;
+                    toolCallCount++;
+                    const toolStartEvent = {
+                      toolCallId: currentToolCall.id,
+                      toolCallName: currentToolCall.name,
+                      parentMessageId,
+                      type: import_client.EventType.TOOL_CALL_START
+                    };
+                    logger.debug?.(
+                      {
+                        toolCallId: toolCall.id,
+                        toolCallName: toolCall.name
+                      },
+                      "Tool call started"
+                    );
+                    logger.trace?.(
+                      { aguiEvent: toolStartEvent },
+                      "Emitting AGUI event"
+                    );
+                    subscriber.next(toolStartEvent);
+                    if (currentToolCall.args) {
+                      const toolArgsEvent = {
+                        toolCallId: currentToolCall.id,
+                        delta: currentToolCall.args,
+                        type: import_client.EventType.TOOL_CALL_ARGS
+                      };
+                      logger.trace?.(
+                        { aguiEvent: toolArgsEvent },
+                        "Emitting AGUI event"
+                      );
+                      subscriber.next(toolArgsEvent);
+                      if (isValidJson(currentToolCall.args)) {
+                        const toolEndEvent2 = {
+                          toolCallId: currentToolCall.id,
+                          type: import_client.EventType.TOOL_CALL_END
+                        };
+                        logger.debug?.(
+                          { toolCallId: currentToolCall.id },
+                          "Tool call ended (args complete)"
+                        );
+                        logger.trace?.(
+                          { aguiEvent: toolEndEvent2 },
+                          "Emitting AGUI event"
+                        );
+                        subscriber.next(toolEndEvent2);
+                        currentToolCall = null;
+                      }
+                    }
+                  }
+                } else {
+                  if (toolCall.args) {
+                    currentToolCall.args += toolCall.args;
+                    const toolArgsEvent = {
                       toolCallId: currentToolCall.id,
-                      delta: currentToolCall.args,
+                      delta: toolCall.args,
                       type: import_client.EventType.TOOL_CALL_ARGS
-                    });
+                    };
+                    logger.trace?.(
+                      { aguiEvent: toolArgsEvent },
+                      "Emitting AGUI event"
+                    );
+                    subscriber.next(toolArgsEvent);
                     if (isValidJson(currentToolCall.args)) {
-                      subscriber.next({
+                      const toolEndEvent = {
                         toolCallId: currentToolCall.id,
                         type: import_client.EventType.TOOL_CALL_END
-                      });
+                      };
+                      logger.debug?.(
+                        { toolCallId: currentToolCall.id },
+                        "Tool call ended (args complete)"
+                      );
+                      logger.trace?.(
+                        { aguiEvent: toolEndEvent },
+                        "Emitting AGUI event"
+                      );
+                      subscriber.next(toolEndEvent);
                       currentToolCall = null;
                     }
                   }
                 }
               } else {
-                if (toolCall.args) {
-                  currentToolCall.args += toolCall.args;
-                  subscriber.next({
-                    toolCallId: currentToolCall.id,
-                    delta: toolCall.args,
-                    type: import_client.EventType.TOOL_CALL_ARGS
-                  });
-                  if (isValidJson(currentToolCall.args)) {
-                    subscriber.next({
-                      toolCallId: currentToolCall.id,
-                      type: import_client.EventType.TOOL_CALL_END
-                    });
-                    currentToolCall = null;
-                  }
-                }
-              }
-            } else {
-              if (toolCall.name && toolCall.id) {
-                currentToolCall = toolCall;
-                subscriber.next({
-                  toolCallId: toolCall.id,
-                  toolCallName: toolCall.name,
-                  parentMessageId,
-                  type: import_client.EventType.TOOL_CALL_START
-                });
-                if (toolCall.args) {
-                  subscriber.next({
+                if (toolCall.name && toolCall.id) {
+                  currentToolCall = toolCall;
+                  toolCallCount++;
+                  const toolStartEvent = {
                     toolCallId: toolCall.id,
-                    delta: toolCall.args,
-                    type: import_client.EventType.TOOL_CALL_ARGS
-                  });
-                  if (isValidJson(toolCall.args)) {
-                    subscriber.next({
+                    toolCallName: toolCall.name,
+                    parentMessageId,
+                    type: import_client.EventType.TOOL_CALL_START
+                  };
+                  logger.debug?.(
+                    { toolCallId: toolCall.id, toolCallName: toolCall.name },
+                    "Tool call started"
+                  );
+                  logger.trace?.(
+                    { aguiEvent: toolStartEvent },
+                    "Emitting AGUI event"
+                  );
+                  subscriber.next(toolStartEvent);
+                  if (toolCall.args) {
+                    const toolArgsEvent = {
                       toolCallId: toolCall.id,
-                      type: import_client.EventType.TOOL_CALL_END
-                    });
-                    currentToolCall = null;
+                      delta: toolCall.args,
+                      type: import_client.EventType.TOOL_CALL_ARGS
+                    };
+                    logger.trace?.(
+                      { aguiEvent: toolArgsEvent },
+                      "Emitting AGUI event"
+                    );
+                    subscriber.next(toolArgsEvent);
+                    if (isValidJson(toolCall.args)) {
+                      const toolEndEvent = {
+                        toolCallId: toolCall.id,
+                        type: import_client.EventType.TOOL_CALL_END
+                      };
+                      logger.debug?.(
+                        { toolCallId: toolCall.id },
+                        "Tool call ended (args complete)"
+                      );
+                      logger.trace?.(
+                        { aguiEvent: toolEndEvent },
+                        "Emitting AGUI event"
+                      );
+                      subscriber.next(toolEndEvent);
+                      currentToolCall = null;
+                    }
                   }
                 }
               }
-            }
-          });
-        }
-        const delta = event.data.chunk.content;
-        if (typeof delta === "string" && delta) {
-          subscriber.next({
-            messageId: chatModelRun.messageId,
-            type: import_client.EventType.TEXT_MESSAGE_CONTENT,
-            delta
-          });
+            });
+          }
+          const delta = event.data.chunk.content;
+          if (typeof delta === "string" && delta) {
+            textChunkCount++;
+            const textContentEvent = {
+              messageId: chatModelRun.messageId,
+              type: import_client.EventType.TEXT_MESSAGE_CONTENT,
+              delta
+            };
+            logger.trace?.(
+              { aguiEvent: textContentEvent },
+              "Emitting AGUI event"
+            );
+            subscriber.next(textContentEvent);
+          }
+          continue;
         }
-        continue;
-      }
-      if (event.event === "on_chat_model_end") {
-        const chatModelRun = chatModelRuns.find(
-          (run) => run.runId === event.run_id
-        );
-        if (!chatModelRun) {
-          subscriber.next({
-            type: import_client.EventType.RUN_ERROR,
-            message: `Received a on_chat_model_end event from an unknown chat model run. Run Id: ${event.run_id}`
-          });
+        if (event.event === "on_chat_model_end") {
+          const chatModelRun = chatModelRuns.find(
+            (run) => run.runId === event.run_id
+          );
+          if (!chatModelRun) {
+            logger.warn?.(
+              { chatModelRunId: event.run_id },
+              "Received on_chat_model_end from unknown run"
+            );
+            subscriber.next({
+              type: import_client.EventType.RUN_ERROR,
+              message: `Received a on_chat_model_end event from an unknown chat model run. Run Id: ${event.run_id}`
+            });
+            continue;
+          }
+          const textEndEvent = {
+            type: import_client.EventType.TEXT_MESSAGE_END,
+            messageId: chatModelRun.messageId
+          };
+          logger.debug?.(
+            { messageId: chatModelRun.messageId },
+            "Text message ended"
+          );
+          logger.trace?.({ aguiEvent: textEndEvent }, "Emitting AGUI event");
+          subscriber.next(textEndEvent);
           continue;
         }
-        subscriber.next({
-          type: import_client.EventType.TEXT_MESSAGE_END,
-          messageId: chatModelRun.messageId
-        });
-        continue;
-      }
-      if (event.event === "on_tool_end") {
-        const toolMessage = event.data.output;
-        if (toolMessage && toolMessage.tool_call_id) {
-          if (!handledToolCallIds.has(toolMessage.tool_call_id)) {
-            if (!toolMessage.id) {
-              toolMessage.id = crypto.randomUUID();
-              if (toolMessage.lc_kwargs) {
-                toolMessage.lc_kwargs.id = toolMessage.id;
+        if (event.event === "on_tool_end") {
+          const toolMessage = event.data.output;
+          if (toolMessage && toolMessage.tool_call_id) {
+            if (!handledToolCallIds.has(toolMessage.tool_call_id)) {
+              if (!toolMessage.id) {
+                toolMessage.id = crypto.randomUUID();
+                if (toolMessage.lc_kwargs) {
+                  toolMessage.lc_kwargs.id = toolMessage.id;
+                }
               }
+              const toolResultEvent = {
+                toolCallId: toolMessage.tool_call_id,
+                type: import_client.EventType.TOOL_CALL_RESULT,
+                content: typeof toolMessage.content === "string" ? toolMessage.content : JSON.stringify(toolMessage.content),
+                messageId: toolMessage.id
+              };
+              logger.debug?.(
+                {
+                  toolCallId: toolMessage.tool_call_id,
+                  messageId: toolMessage.id
+                },
+                "Tool call result received"
+              );
+              logger.trace?.(
+                { aguiEvent: toolResultEvent },
+                "Emitting AGUI event"
+              );
+              subscriber.next(toolResultEvent);
+              handledToolCallIds.add(toolMessage.tool_call_id);
+            } else {
+              logger.trace?.(
+                { toolCallId: toolMessage.tool_call_id },
+                "Skipping duplicate tool call result"
+              );
             }
-            subscriber.next({
-              toolCallId: toolMessage.tool_call_id,
-              type: import_client.EventType.TOOL_CALL_RESULT,
-              content: typeof toolMessage.content === "string" ? toolMessage.content : JSON.stringify(toolMessage.content),
-              messageId: toolMessage.id
-            });
-            handledToolCallIds.add(toolMessage.tool_call_id);
           }
+          continue;
+        }
+        if (event.event === "on_chain_stream" && event.data.chunk?.__interrupt__ && Array.isArray(event.data.chunk.__interrupt__) && event.data.chunk.__interrupt__.length > 0) {
+          const rawInterrupt = event.data.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
+          };
         }
-        continue;
       }
-      if (event.event === "on_chain_stream" && event.data.chunk?.__interrupt__ && Array.isArray(event.data.chunk.__interrupt__) && event.data.chunk.__interrupt__.length > 0) {
-        const rawInterrupt = event.data.chunk.__interrupt__[0];
-        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);
       }
-    }
-    if (interrupt) {
-      subscriber.next({
-        type: import_client.EventType.RUN_FINISHED,
-        threadId,
-        runId,
-        outcome: "interrupt",
-        interrupt
-      });
-    } else {
+    } catch (error) {
+      logger.error?.(
+        { err: error, eventCount, toolCallCount, textChunkCount },
+        "Error during stream processing"
+      );
       subscriber.next({
-        type: import_client.EventType.RUN_FINISHED,
-        threadId,
-        runId
+        type: import_client.EventType.RUN_ERROR,
+        message: error instanceof Error ? error.message : String(error)
       });
     }
     subscriber.complete();
   }
   clone() {
     const workflow = this.compiledWorkflow;
+    const logger = this.logger;
     this.compiledWorkflow = void 0;
     const cloned = super.clone();
     this.compiledWorkflow = workflow;
     cloned.compiledWorkflow = workflow;
+    cloned.logger = logger;
     return cloned;
   }
 };
@@ -389,8 +585,7 @@ function aguiMessagesToLangChain(messages) {
           id: message.id
         };
       default:
-        console.error(`Message role ${message.role} is not implemented`);
-        throw new Error("message role is not supported.");
+        throw new Error(`Message role ${message.role} is not supported.`);
     }
   });
 }
@@ -1078,12 +1273,17 @@ var TDAIStore = class extends import_langgraph3.BaseStore {
     }
   }
 };
+
+// src/index.ts
+var import_agent_shared2 = require("@cloudbase/agent-shared");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClientPropertiesAnnotation,
   ClientStateAnnotation,
   LanggraphAgent,
   TDAISaver,
-  TDAIStore
+  TDAIStore,
+  createConsoleLogger,
+  noopLogger
 });
 //# sourceMappingURL=index.js.map