@macrow/copilotkit-langgraph-history 0.1.7

package/dist/index.cjs

@@ -0,0 +1,947 @@
+'use strict';
+
+var core = require('@ag-ui/core');
+var langgraph = require('@copilotkit/runtime/langgraph');
+var runtime = require('@copilotkitnext/runtime');
+var langgraphSdk = require('@langchain/langgraph-sdk');
+var rxjs = require('rxjs');
+
+// src/runner/history-hydrating-runner.ts
+
+// src/runner/constants.ts
+var DEFAULT_TIMEOUT = 30 * 60 * 1e3;
+var DEFAULT_HISTORY_LIMIT = 100;
+var MAX_HISTORY_LIMIT = 1e3;
+function createIsolatedAgent(config) {
+  const timeout = config.clientTimeoutMs ?? DEFAULT_TIMEOUT;
+  const isolatedConfig = Object.freeze({
+    deploymentUrl: String(config.deploymentUrl),
+    graphId: String(config.graphId),
+    langsmithApiKey: config.langsmithApiKey ? String(config.langsmithApiKey) : void 0,
+    debug: Boolean(config.debug)
+  });
+  const agent = new langgraph.LangGraphAgent(isolatedConfig);
+  const clientInternals = agent.client;
+  const expectedUrl = config.deploymentUrl.replace(/\/$/, "");
+  const actualUrl = clientInternals.apiUrl?.replace(/\/$/, "");
+  if (expectedUrl !== actualUrl) {
+    console.warn(
+      `[LangGraphHistory] URL mismatch detected! Expected: ${expectedUrl}, Got: ${actualUrl}. Replacing client.`
+    );
+    const newClient = new langgraphSdk.Client({
+      apiUrl: config.deploymentUrl,
+      apiKey: config.langsmithApiKey,
+      timeoutMs: timeout,
+      onRequest: config.onRequest
+    });
+    Object.assign(agent, { client: newClient });
+  }
+  return agent;
+}
+
+// src/utils/message-transformer.ts
+function extractContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      if (block.type === "text" && block.text) {
+        return block.text;
+      }
+      return "";
+    }).filter((text) => text.length > 0).join("\n");
+  }
+  return "";
+}
+function transformMessages(messages, options) {
+  const result = [];
+  for (const msg of messages) {
+    try {
+      let transformed = null;
+      switch (msg.type) {
+        case "human": {
+          const content = extractContent(msg.content);
+          transformed = {
+            id: msg.id,
+            role: "user",
+            content
+          };
+          break;
+        }
+        case "ai": {
+          const content = extractContent(msg.content);
+          transformed = {
+            id: msg.id,
+            role: "assistant",
+            content: content || "",
+            toolCalls: msg.tool_calls?.map((toolCall) => ({
+              id: toolCall.id,
+              type: "function",
+              function: {
+                name: toolCall.name,
+                arguments: JSON.stringify(toolCall.args)
+              }
+            }))
+          };
+          break;
+        }
+        case "system": {
+          const content = extractContent(msg.content);
+          transformed = {
+            id: msg.id,
+            role: "system",
+            content
+          };
+          break;
+        }
+        case "tool": {
+          const content = extractContent(msg.content);
+          transformed = {
+            id: msg.id,
+            role: "tool",
+            content,
+            toolCallId: msg.tool_call_id
+          };
+          break;
+        }
+        default:
+          if (options?.debug) {
+            console.warn(
+              `[HistoryHydratingRunner] Unknown message type: ${msg.type}`
+            );
+          }
+      }
+      if (transformed) {
+        result.push(transformed);
+      }
+    } catch (error) {
+      if (options?.debug) {
+        console.warn(
+          "[HistoryHydratingRunner] Failed to transform message:",
+          msg,
+          error
+        );
+      }
+    }
+  }
+  return result;
+}
+
+// src/events/custom-events.ts
+var CustomEventNames = /* @__PURE__ */ ((CustomEventNames2) => {
+  CustomEventNames2["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
+  CustomEventNames2["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
+  CustomEventNames2["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
+  CustomEventNames2["CopilotKitExit"] = "copilotkit_exit";
+  return CustomEventNames2;
+})(CustomEventNames || {});
+
+// src/events/langgraph-events.ts
+var LangGraphEventTypes = /* @__PURE__ */ ((LangGraphEventTypes2) => {
+  LangGraphEventTypes2["OnChatModelStart"] = "on_chat_model_start";
+  LangGraphEventTypes2["OnChatModelStream"] = "on_chat_model_stream";
+  LangGraphEventTypes2["OnChatModelEnd"] = "on_chat_model_end";
+  LangGraphEventTypes2["OnToolStart"] = "on_tool_start";
+  LangGraphEventTypes2["OnToolEnd"] = "on_tool_end";
+  LangGraphEventTypes2["OnChainStart"] = "on_chain_start";
+  LangGraphEventTypes2["OnChainEnd"] = "on_chain_end";
+  return LangGraphEventTypes2;
+})(LangGraphEventTypes || {});
+
+// src/utils/stream-processor.ts
+async function processStreamChunk(chunk, context) {
+  const { event, data } = chunk;
+  let { runId } = context;
+  const { threadId, subscriber, startedMessages, startedToolCalls, debug } = context;
+  let manuallyEmittedState = context.manuallyEmittedState;
+  switch (event) {
+    case "metadata": {
+      const metadataData = data;
+      if (metadataData.run_id) {
+        runId = metadataData.run_id;
+      }
+      break;
+    }
+    case "events": {
+      const eventsData = data;
+      const rawEvent = {
+        type: "RAW",
+        event: eventsData.event,
+        name: eventsData.name,
+        data: eventsData.data,
+        run_id: eventsData.run_id,
+        metadata: chunk.metadata,
+        rawEvent: {
+          id: runId,
+          event: eventsData.event,
+          name: eventsData.name,
+          data: eventsData.data,
+          run_id: eventsData.run_id,
+          metadata: chunk.metadata
+        },
+        timestamp: Date.now(),
+        threadId,
+        runId
+      };
+      const eventType = eventsData.event;
+      const toolCallData = eventsData.data?.chunk?.tool_call_chunks?.[0];
+      const metadata = chunk.metadata || {};
+      const emitIntermediateState = metadata["copilotkit:emit-intermediate-state"];
+      const toolCallUsedToPredictState = emitIntermediateState?.some(
+        (predictStateTool) => predictStateTool.tool === toolCallData?.name
+      );
+      if (eventType === "on_chat_model_stream" /* OnChatModelStream */ && toolCallUsedToPredictState) {
+        subscriber.next({
+          type: "CUSTOM",
+          name: "PredictState",
+          value: metadata["copilotkit:emit-intermediate-state"],
+          rawEvent,
+          timestamp: Date.now(),
+          threadId,
+          runId
+        });
+        break;
+      }
+      if (eventType === "on_chat_model_stream" /* OnChatModelStream */) {
+        const messageChunk = eventsData.data?.chunk;
+        if (messageChunk?.content) {
+          if ("copilotkit:emit-messages" in metadata && metadata["copilotkit:emit-messages"] === false) {
+            break;
+          }
+          const messageId = eventsData.run_id || runId;
+          const delta = typeof messageChunk.content === "string" ? messageChunk.content : "";
+          if (startedMessages && !startedMessages.has(messageId)) {
+            subscriber.next({
+              type: "TEXT_MESSAGE_START",
+              role: "assistant",
+              messageId,
+              rawEvent,
+              timestamp: Date.now(),
+              threadId,
+              runId
+            });
+            startedMessages.add(messageId);
+          }
+          subscriber.next({
+            type: "TEXT_MESSAGE_CONTENT",
+            messageId,
+            delta,
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+        }
+      }
+      if (eventType === "on_chat_model_start" /* OnChatModelStart */) {
+        const eventMetadata = chunk.metadata || {};
+        if ("copilotkit:emit-messages" in eventMetadata && eventMetadata["copilotkit:emit-messages"] === false) {
+          break;
+        }
+        const messageId = eventsData.run_id || runId;
+        if (!startedMessages || !startedMessages.has(messageId)) {
+          subscriber.next({
+            type: "TEXT_MESSAGE_START",
+            role: "assistant",
+            messageId,
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          if (startedMessages) {
+            startedMessages.add(messageId);
+          }
+        }
+      }
+      if (eventType === "on_chat_model_end" /* OnChatModelEnd */) {
+        const eventMetadata = chunk.metadata || {};
+        if ("copilotkit:emit-messages" in eventMetadata && eventMetadata["copilotkit:emit-messages"] === false) {
+          break;
+        }
+        const messageId = eventsData.run_id || runId;
+        if (startedMessages && !startedMessages.has(messageId)) {
+          subscriber.next({
+            type: "TEXT_MESSAGE_START",
+            role: "assistant",
+            messageId,
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          startedMessages.add(messageId);
+        }
+        subscriber.next({
+          type: "TEXT_MESSAGE_END",
+          messageId,
+          rawEvent,
+          timestamp: Date.now(),
+          threadId,
+          runId
+        });
+      }
+      if (eventType === "on_tool_start" /* OnToolStart */) {
+        const eventMetadata = chunk.metadata || {};
+        if ("copilotkit:emit-tool-calls" in eventMetadata && eventMetadata["copilotkit:emit-tool-calls"] === false) {
+          break;
+        }
+        const toolData = eventsData.data?.input;
+        const toolName = eventsData.name;
+        const toolCallId = eventsData.run_id || runId;
+        if (!startedToolCalls || !startedToolCalls.has(toolCallId)) {
+          subscriber.next({
+            type: "TOOL_CALL_START",
+            toolCallId,
+            toolCallName: toolName,
+            parentMessageId: runId,
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          if (startedToolCalls) {
+            startedToolCalls.add(toolCallId);
+          }
+        }
+        if (toolData) {
+          subscriber.next({
+            type: "TOOL_CALL_ARGS",
+            toolCallId,
+            delta: JSON.stringify(toolData),
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+        }
+      }
+      if (eventType === "on_tool_end" /* OnToolEnd */) {
+        const eventMetadata = chunk.metadata || {};
+        if ("copilotkit:emit-tool-calls" in eventMetadata && eventMetadata["copilotkit:emit-tool-calls"] === false) {
+          break;
+        }
+        const toolCallId = eventsData.run_id || runId;
+        const toolName = eventsData.name;
+        if (startedToolCalls && !startedToolCalls.has(toolCallId)) {
+          subscriber.next({
+            type: "TOOL_CALL_START",
+            toolCallId,
+            toolCallName: toolName,
+            parentMessageId: runId,
+            rawEvent,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          startedToolCalls.add(toolCallId);
+        }
+        subscriber.next({
+          type: "TOOL_CALL_END",
+          toolCallId,
+          rawEvent,
+          timestamp: Date.now(),
+          threadId,
+          runId
+        });
+      }
+      subscriber.next({
+        type: "CUSTOM",
+        name: eventsData.event,
+        value: JSON.stringify(eventsData.data),
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "updates": {
+      const updatesData = data;
+      subscriber.next({
+        type: "STATE_SNAPSHOT",
+        snapshot: updatesData,
+        rawEvent: {
+          id: runId,
+          event: "updates",
+          data: updatesData
+        },
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "values": {
+      const valuesData = data;
+      subscriber.next({
+        type: "STATE_SNAPSHOT",
+        snapshot: valuesData,
+        rawEvent: {
+          id: runId,
+          event: "values",
+          data: valuesData
+        },
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "custom": {
+      const customData = data;
+      const result = handleCustomEvent(
+        customData,
+        threadId,
+        runId,
+        subscriber,
+        manuallyEmittedState
+      );
+      manuallyEmittedState = result.manuallyEmittedState;
+      break;
+    }
+    case "error": {
+      const errorData = data;
+      if (debug) {
+        console.error(
+          "[HistoryHydratingRunner] Stream error:",
+          errorData.message
+        );
+      }
+      subscriber.next({
+        type: "CUSTOM",
+        name: "on_error",
+        value: JSON.stringify(errorData),
+        rawEvent: {
+          id: runId,
+          error: errorData.error,
+          message: errorData.message
+        },
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    default: {
+      if (debug) {
+        console.log(
+          `[HistoryHydratingRunner] Unhandled event type: ${event}`,
+          data
+        );
+      }
+    }
+  }
+  return { runId, manuallyEmittedState };
+}
+function handleCustomEvent(customData, threadId, runId, subscriber, manuallyEmittedState) {
+  const rawEvent = {
+    id: runId,
+    data: customData
+  };
+  const typedData = customData;
+  const eventName = typedData?.name || typedData?.event;
+  switch (eventName) {
+    case "copilotkit_manually_emit_message" /* CopilotKitManuallyEmitMessage */: {
+      const value = typedData.value;
+      const messageId = value?.message_id || runId;
+      const message = value?.message || "";
+      subscriber.next({
+        type: "TEXT_MESSAGE_START",
+        role: "assistant",
+        messageId,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      subscriber.next({
+        type: "TEXT_MESSAGE_CONTENT",
+        messageId,
+        delta: message,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      subscriber.next({
+        type: "TEXT_MESSAGE_END",
+        messageId,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "copilotkit_manually_emit_tool_call" /* CopilotKitManuallyEmitToolCall */: {
+      const value = typedData.value;
+      const toolCallId = value?.id || runId;
+      const toolCallName = value?.name || "";
+      const args = value?.args || {};
+      subscriber.next({
+        type: "TOOL_CALL_START",
+        toolCallId,
+        toolCallName,
+        parentMessageId: toolCallId,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      subscriber.next({
+        type: "TOOL_CALL_ARGS",
+        toolCallId,
+        delta: JSON.stringify(args),
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      subscriber.next({
+        type: "TOOL_CALL_END",
+        toolCallId,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "copilotkit_manually_emit_intermediate_state" /* CopilotKitManuallyEmitIntermediateState */: {
+      manuallyEmittedState = typedData.value;
+      subscriber.next({
+        type: "STATE_SNAPSHOT",
+        snapshot: manuallyEmittedState,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    case "copilotkit_exit" /* CopilotKitExit */: {
+      subscriber.next({
+        type: "CUSTOM",
+        name: "Exit",
+        value: true,
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      break;
+    }
+    default: {
+      subscriber.next({
+        type: "CUSTOM",
+        name: eventName || "on_custom_event",
+        value: JSON.stringify(customData),
+        rawEvent,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+    }
+  }
+  return { manuallyEmittedState };
+}
+
+// src/runner/history-hydrating-runner.ts
+var HistoryHydratingAgentRunner = class extends runtime.AgentRunner {
+  agent;
+  historyLimit;
+  debug;
+  stateExtractor;
+  activeRun = {};
+  /**
+   * Frozen agent config to prevent shared state contamination.
+   * We store the raw config values and create fresh Agent/Client instances per request.
+   * This is critical because Vercel serverless can bundle multiple routes together,
+   * causing module-level state to leak between different agent configurations.
+   */
+  frozenConfig;
+  constructor(config) {
+    super();
+    this.agent = config.agent;
+    this.debug = config.debug ?? false;
+    this.stateExtractor = config.stateExtractor;
+    this.historyLimit = Math.min(
+      config.historyLimit ?? DEFAULT_HISTORY_LIMIT,
+      MAX_HISTORY_LIMIT
+    );
+    this.frozenConfig = Object.freeze({
+      deploymentUrl: config.deploymentUrl,
+      graphId: config.graphId,
+      langsmithApiKey: config.langsmithApiKey,
+      clientTimeoutMs: config.clientTimeoutMs ?? DEFAULT_TIMEOUT,
+      onRequest: config.onRequest
+    });
+  }
+  /**
+   * Creates a fresh LangGraphAgent instance using the frozen config.
+   * Uses our isolated agent creator to prevent shared state contamination.
+   */
+  createFreshAgent() {
+    return createIsolatedAgent({
+      deploymentUrl: this.frozenConfig.deploymentUrl,
+      graphId: this.frozenConfig.graphId,
+      langsmithApiKey: this.frozenConfig.langsmithApiKey,
+      clientTimeoutMs: this.frozenConfig.clientTimeoutMs,
+      onRequest: this.frozenConfig.onRequest
+    });
+  }
+  /**
+   * Creates a fresh LangGraph Client instance using the frozen config.
+   * This prevents shared state contamination in serverless environments.
+   */
+  createFreshClient() {
+    return new langgraphSdk.Client({
+      apiUrl: this.frozenConfig.deploymentUrl,
+      apiKey: this.frozenConfig.langsmithApiKey,
+      timeoutMs: this.frozenConfig.clientTimeoutMs,
+      onRequest: this.frozenConfig.onRequest
+    });
+  }
+  /**
+   * Log a message if debug mode is enabled.
+   */
+  log(message, ...args) {
+    if (this.debug) {
+      console.log(`[HistoryHydratingRunner] ${message}`, ...args);
+    }
+  }
+  /**
+   * Log a warning.
+   */
+  warn(message, ...args) {
+    console.warn(`[HistoryHydratingRunner] ${message}`, ...args);
+  }
+  /**
+   * Log an error.
+   */
+  error(message, ...args) {
+    console.error(`[HistoryHydratingRunner] ${message}`, ...args);
+  }
+  /**
+   * Run the agent with a FRESH agent instance.
+   * CRITICAL: We cannot trust request.agent (cloned by CopilotKit) because
+   * its internal Client may have been corrupted by shared module state in
+   * Vercel serverless environments. Create a completely fresh agent with
+   * our frozen config to guarantee the correct deployment URL is used.
+   */
+  run(request) {
+    const freshAgent = this.createFreshAgent();
+    const inputWithProps = request.input;
+    const forwardedProps = inputWithProps.forwardedProps;
+    const existingState = request.input.state || {};
+    let enrichedState;
+    if (this.stateExtractor) {
+      const extractedState = this.stateExtractor(request.input, forwardedProps);
+      enrichedState = {
+        ...existingState,
+        ...extractedState
+      };
+    } else {
+      enrichedState = existingState;
+    }
+    this.log("State extraction:", {
+      hasStateExtractor: !!this.stateExtractor,
+      hasForwardedProps: !!forwardedProps,
+      hasState: !!request.input.state,
+      threadId: request.input.threadId
+    });
+    freshAgent.setState(enrichedState);
+    const inputWithState = {
+      ...request.input,
+      state: enrichedState
+    };
+    return freshAgent.run(inputWithState);
+  }
+  /**
+   * Delegate isRunning to the agent.
+   */
+  async isRunning() {
+    return this.agent.isRunning;
+  }
+  /**
+   * Delegate stop to the agent.
+   */
+  async stop(_request) {
+    const result = this.agent.abortRun();
+    return result !== void 0 ? result : true;
+  }
+  /**
+   * Override connect to add history hydration support.
+   *
+   * When reconnecting to a thread:
+   * 1. Fetches ALL thread history (checkpoints) from LangGraph
+   * 2. Extracts and deduplicates messages from all checkpoints
+   * 3. Transforms historical messages to CopilotKit format
+   * 4. Emits MESSAGES_SNAPSHOT and STATE_SNAPSHOT events
+   * 5. Completes the observable
+   */
+  connect(request) {
+    const { threadId } = request;
+    const client = this.createFreshClient();
+    return new rxjs.Observable((subscriber) => {
+      const hydrate = async () => {
+        try {
+          const history = await client.threads.getHistory(threadId, {
+            limit: this.historyLimit > 0 ? this.historyLimit : DEFAULT_HISTORY_LIMIT
+          });
+          if (!history || history.length === 0) {
+            this.warn(`No history found for thread ${threadId}`);
+            const fallbackRunId = "hydration_" + Math.random().toString(36).slice(2);
+            subscriber.next({
+              type: core.EventType.RUN_STARTED,
+              timestamp: Date.now(),
+              threadId,
+              runId: fallbackRunId
+            });
+            subscriber.next({
+              type: core.EventType.MESSAGES_SNAPSHOT,
+              messages: [],
+              timestamp: Date.now(),
+              threadId,
+              runId: fallbackRunId
+            });
+            subscriber.next({
+              type: core.EventType.RUN_FINISHED,
+              timestamp: Date.now(),
+              threadId,
+              runId: fallbackRunId
+            });
+            subscriber.complete();
+            return;
+          }
+          const allMessages = [];
+          const seenMessageIds = /* @__PURE__ */ new Set();
+          for (const checkpoint of history.reverse()) {
+            const state = checkpoint;
+            if (state.values?.messages) {
+              const messages = state.values.messages || [];
+              for (const msg of messages) {
+                if (!seenMessageIds.has(msg.id)) {
+                  seenMessageIds.add(msg.id);
+                  allMessages.push(msg);
+                }
+              }
+            }
+          }
+          this.log(
+            `Loaded ${allMessages.length} unique messages from ${history.length} checkpoints`
+          );
+          const limitedMessages = this.historyLimit > 0 ? allMessages.slice(-this.historyLimit) : allMessages;
+          const transformedMessages = transformMessages(limitedMessages, {
+            debug: this.debug
+          });
+          let runId;
+          try {
+            const runs = await client.runs.list(threadId);
+            runId = runs && runs.length > 0 ? runs[0].run_id : "hydration_" + Math.random().toString(36).slice(2);
+          } catch (error) {
+            this.warn("Failed to fetch runs, using generated ID:", error);
+            runId = "hydration_" + Math.random().toString(36).slice(2);
+          }
+          subscriber.next({
+            type: core.EventType.RUN_STARTED,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          subscriber.next({
+            type: core.EventType.MESSAGES_SNAPSHOT,
+            messages: transformedMessages,
+            timestamp: Date.now(),
+            threadId,
+            runId
+          });
+          const latestState = history[history.length - 1];
+          if (latestState.values) {
+            subscriber.next({
+              type: "STATE_SNAPSHOT",
+              snapshot: latestState.values,
+              rawEvent: {
+                id: runId,
+                event: "values",
+                data: latestState.values
+              },
+              timestamp: Date.now(),
+              threadId,
+              runId
+            });
+          }
+          const interruptedTask = latestState.tasks?.find(
+            (task) => task.interrupts && task.interrupts.length > 0
+          );
+          if (interruptedTask && interruptedTask.interrupts && interruptedTask.interrupts.length > 0) {
+            const interrupt = interruptedTask.interrupts[0];
+            const interruptValue = interrupt?.value;
+            subscriber.next({
+              type: "CUSTOM",
+              name: "on_interrupt",
+              value: JSON.stringify(interruptValue),
+              rawEvent: {
+                id: runId,
+                value: interruptValue
+              },
+              timestamp: Date.now(),
+              threadId,
+              runId
+            });
+          }
+          const isThreadBusy = latestState.next && latestState.next.length > 0;
+          let activeRun;
+          if (isThreadBusy) {
+            try {
+              const runs = await client.runs.list(threadId);
+              activeRun = runs?.find(
+                (run) => run.status === "running" || run.status === "pending"
+              );
+            } catch (error) {
+              this.warn("Failed to check for active runs:", error);
+            }
+          }
+          if (activeRun) {
+            this.log(`Joining active stream for run ${activeRun.run_id}`);
+            try {
+              await this.joinAndProcessStream(
+                client,
+                threadId,
+                activeRun.run_id,
+                subscriber
+              );
+            } catch (error) {
+              this.error("Error joining stream:", error);
+            }
+          } else {
+            subscriber.next({
+              type: core.EventType.RUN_FINISHED,
+              timestamp: Date.now(),
+              threadId,
+              runId
+            });
+          }
+          subscriber.complete();
+        } catch (error) {
+          this.error("Failed to hydrate history:", error);
+          const fallbackRunId = "hydration_error_" + Math.random().toString(36).slice(2);
+          subscriber.next({
+            type: core.EventType.RUN_STARTED,
+            timestamp: Date.now(),
+            threadId,
+            runId: fallbackRunId
+          });
+          subscriber.next({
+            type: core.EventType.MESSAGES_SNAPSHOT,
+            messages: [],
+            timestamp: Date.now(),
+            threadId,
+            runId: fallbackRunId
+          });
+          subscriber.next({
+            type: core.EventType.RUN_FINISHED,
+            timestamp: Date.now(),
+            threadId,
+            runId: fallbackRunId
+          });
+          subscriber.complete();
+        }
+      };
+      hydrate();
+    });
+  }
+  /**
+   * Joins an active stream and processes its events.
+   *
+   * This method connects to an already-running LangGraph execution and
+   * processes all incoming events, transforming them to BaseEvent format.
+   *
+   * Tracks started messages and tool calls to handle mid-stream joins where
+   * we might receive CONTENT/END events without having seen START events.
+   */
+  async joinAndProcessStream(client, threadId, runId, subscriber) {
+    const startedMessages = /* @__PURE__ */ new Set();
+    const startedToolCalls = /* @__PURE__ */ new Set();
+    try {
+      const stream = client.runs.joinStream(threadId, runId, {
+        streamMode: ["events", "values", "updates", "custom"]
+      });
+      let currentRunId = runId;
+      let manuallyEmittedState = this.activeRun.manuallyEmittedState;
+      for await (const chunk of stream) {
+        try {
+          const result = await processStreamChunk(chunk, {
+            threadId,
+            runId: currentRunId,
+            subscriber,
+            startedMessages,
+            startedToolCalls,
+            debug: this.debug,
+            manuallyEmittedState
+          });
+          currentRunId = result.runId;
+          manuallyEmittedState = result.manuallyEmittedState;
+        } catch (chunkError) {
+          this.error("Error processing stream chunk:", chunkError);
+        }
+      }
+      this.activeRun.manuallyEmittedState = manuallyEmittedState;
+      try {
+        const state = await client.threads.getState(threadId);
+        const threadState = state;
+        const interruptedTask = threadState.tasks?.find(
+          (task) => task.interrupts && task.interrupts.length > 0
+        );
+        if (interruptedTask && interruptedTask.interrupts && interruptedTask.interrupts.length > 0) {
+          const interrupt = interruptedTask.interrupts[0];
+          const interruptValue = interrupt?.value;
+          subscriber.next({
+            type: "CUSTOM",
+            name: "on_interrupt",
+            value: JSON.stringify(interruptValue),
+            rawEvent: {
+              id: currentRunId,
+              value: interruptValue
+            },
+            timestamp: Date.now(),
+            threadId,
+            runId: currentRunId
+          });
+        }
+      } catch (stateError) {
+        this.warn("Failed to check for interrupts after stream:", stateError);
+      }
+      subscriber.next({
+        type: core.EventType.RUN_FINISHED,
+        timestamp: Date.now(),
+        threadId,
+        runId: currentRunId
+      });
+    } catch (error) {
+      this.error("Error in joinAndProcessStream:", error);
+      subscriber.next({
+        type: core.EventType.RUN_FINISHED,
+        timestamp: Date.now(),
+        threadId,
+        runId
+      });
+      throw error;
+    }
+  }
+};
+
+exports.CustomEventNames = CustomEventNames;
+exports.DEFAULT_HISTORY_LIMIT = DEFAULT_HISTORY_LIMIT;
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.HistoryHydratingAgentRunner = HistoryHydratingAgentRunner;
+exports.LangGraphEventTypes = LangGraphEventTypes;
+exports.MAX_HISTORY_LIMIT = MAX_HISTORY_LIMIT;
+exports.createIsolatedAgent = createIsolatedAgent;
+exports.extractContent = extractContent;
+exports.processStreamChunk = processStreamChunk;
+exports.transformMessages = transformMessages;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map