@cloudbase/agent-adapter-langgraph 0.0.13 → 1.0.1-alpha.7

package/dist/index.js

@@ -34,9 +34,7 @@ __export(index_exports, {
   ClientStateAnnotation: () => ClientStateAnnotation,
   LanggraphAgent: () => LanggraphAgent,
   TDAISaver: () => TDAISaver,
-  TDAIStore: () => TDAIStore,
-  createConsoleLogger: () => import_agent_shared2.createConsoleLogger,
-  noopLogger: () => import_agent_shared2.noopLogger
+  TDAIStore: () => TDAIStore
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -93,7 +91,6 @@ 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
 });
@@ -105,8 +102,6 @@ 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) => {
@@ -115,29 +110,12 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
   }
   async _run(subscriber, input) {
     const { messages, runId, threadId } = input;
-    const logger = this.logger.child?.({ runId, threadId }) ?? this.logger;
-    logger.info?.("Run started");
-    const runStartedEvent = {
+    subscriber.next({
       type: import_client.EventType.RUN_STARTED,
       threadId,
       runId
-    };
-    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({
+    });
+    const streamEventInput = input.forwardedProps?.resume ? new import_langgraph.Command({
       resume: JSON.stringify(input.forwardedProps?.resume?.payload)
     }) : {
       messages: aguiMessagesToLangChain(messages),
@@ -157,7 +135,6 @@ 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) {
@@ -165,32 +142,14 @@ 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;
-    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 (event.event.startsWith("ChannelWrite<")) {
           continue;
         }
         if (event.event === "on_chat_model_start") {
-          logger.debug?.(
-            { chatModelRunId: event.run_id },
-            "Chat model started"
-          );
           chatModelRuns.push({ runId: event.run_id });
           continue;
         }
@@ -199,10 +158,6 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
             (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}`
@@ -212,26 +167,12 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
           const chunkId = event.data.chunk.id;
           if (!chatModelRun.messageId) {
             chatModelRun.messageId = chunkId;
-            const textStartEvent = {
+            subscriber.next({
               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}`
@@ -246,68 +187,29 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
             })).forEach((toolCall) => {
               if (currentToolCall) {
                 if (toolCall.id && currentToolCall.id !== toolCall.id) {
-                  const toolEndEvent = {
+                  subscriber.next({
                     toolCallId: currentToolCall.id,
                     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 = {
+                    subscriber.next({
                       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 = {
+                      subscriber.next({
                         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 = {
+                        subscriber.next({
                           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;
                       }
                     }
@@ -315,30 +217,16 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
                 } else {
                   if (toolCall.args) {
                     currentToolCall.args += toolCall.args;
-                    const toolArgsEvent = {
+                    subscriber.next({
                       toolCallId: currentToolCall.id,
                       delta: toolCall.args,
                       type: import_client.EventType.TOOL_CALL_ARGS
-                    };
-                    logger.trace?.(
-                      { aguiEvent: toolArgsEvent },
-                      "Emitting AGUI event"
-                    );
-                    subscriber.next(toolArgsEvent);
+                    });
                     if (isValidJson(currentToolCall.args)) {
-                      const toolEndEvent = {
+                      subscriber.next({
                         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;
                     }
                   }
@@ -346,47 +234,23 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
               } else {
                 if (toolCall.name && toolCall.id) {
                   currentToolCall = toolCall;
-                  toolCallCount++;
-                  const toolStartEvent = {
+                  subscriber.next({
                     toolCallId: toolCall.id,
                     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 = {
+                    subscriber.next({
                       toolCallId: toolCall.id,
                       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 = {
+                      subscriber.next({
                         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;
                     }
                   }
@@ -396,17 +260,11 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
           }
           const delta = event.data.chunk.content;
           if (typeof delta === "string" && delta) {
-            textChunkCount++;
-            const textContentEvent = {
+            subscriber.next({
               messageId: chatModelRun.messageId,
               type: import_client.EventType.TEXT_MESSAGE_CONTENT,
               delta
-            };
-            logger.trace?.(
-              { aguiEvent: textContentEvent },
-              "Emitting AGUI event"
-            );
-            subscriber.next(textContentEvent);
+            });
           }
           continue;
         }
@@ -415,26 +273,16 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
             (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 = {
+          subscriber.next({
             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;
         }
         if (event.event === "on_tool_end") {
@@ -447,40 +295,19 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
                   toolMessage.lc_kwargs.id = toolMessage.id;
                 }
               }
-              const toolResultEvent = {
+              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
-              };
-              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"
-              );
             }
           }
           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
@@ -489,36 +316,23 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
           };
         }
       }
-      const stats = { eventCount, toolCallCount, textChunkCount };
       if (interrupt) {
-        const runFinishedEvent = {
+        subscriber.next({
           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 = {
+        subscriber.next({
           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 },
-        "Error during stream processing"
-      );
+      console.error("[LanggraphAgent] Error during stream processing:", error);
       subscriber.next({
         type: import_client.EventType.RUN_ERROR,
         message: error instanceof Error ? error.message : String(error)
@@ -528,12 +342,10 @@ var LanggraphAgent = class extends import_client.AbstractAgent {
   }
   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;
   }
 };
@@ -585,7 +397,8 @@ function aguiMessagesToLangChain(messages) {
           id: message.id
         };
       default:
-        throw new Error(`Message role ${message.role} is not supported.`);
+        console.error(`Message role ${message.role} is not implemented`);
+        throw new Error("message role is not supported.");
     }
   });
 }
@@ -1273,17 +1086,12 @@ 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,
-  createConsoleLogger,
-  noopLogger
+  TDAIStore
 });
 //# sourceMappingURL=index.js.map