@langchain/langgraph 0.0.34 → 0.1.0-rc.1

package/dist/pregel/debug.js

@@ -1,22 +1,32 @@
+import { uuid5, } from "@langchain/langgraph-checkpoint";
+import { ERROR, TAG_HIDDEN, TASK_NAMESPACE } from "../constants.js";
 import { EmptyChannelError } from "../errors.js";
+import { readChannels } from "./io.js";
+import { _getIdMetadata } from "./utils.js";
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
         end: "\x1b[0m",
     },
+    green: {
+        start: "\x1b[32m",
+        end: "\x1b[0m",
+    },
+    yellow: {
+        start: "\x1b[33;1m",
+        end: "\x1b[0m",
+    },
 };
 /**
  * Wrap some text in a color for printing to the console.
  */
 const wrap = (color, text) => `${color.start}${text}${color.end}`;
-export function printStepStart(step, nextTasks) {
-    const nTasks = nextTasks.length;
-    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
-        .map((task) => `${String(task.name)}(${JSON.stringify(task.input, null, 2)})`)
-        .join("\n")}`);
-}
 export function printCheckpoint(step, channels) {
-    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+    console.log([
+        `${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`,
+        `Finishing step ${step}. Channel values:\n`,
+        `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`,
+    ].join(""));
 }
 function* _readChannels(channels
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -37,3 +47,133 @@ function* _readChannels(channels
         }
     }
 }
+export function* mapDebugTasks(step, tasks) {
+    const ts = new Date().toISOString();
+    for (const { name, input, config, triggers } of tasks) {
+        if (config?.tags?.includes(TAG_HIDDEN))
+            continue;
+        const metadata = { ...config?.metadata };
+        const idMetadata = _getIdMetadata({
+            langgraph_step: metadata.langgraph_step,
+            langgraph_node: metadata.langgraph_node,
+            langgraph_triggers: metadata.langgraph_triggers,
+            langgraph_task_idx: metadata.langgraph_task_idx,
+        });
+        yield {
+            type: "task",
+            timestamp: ts,
+            step,
+            payload: {
+                id: uuid5(JSON.stringify([name, step, idMetadata]), TASK_NAMESPACE),
+                name,
+                input,
+                triggers,
+            },
+        };
+    }
+}
+export function* mapDebugTaskResults(step, tasks, streamChannelsList) {
+    const ts = new Date().toISOString();
+    for (const { name, writes, config } of tasks) {
+        if (config?.tags?.includes(TAG_HIDDEN))
+            continue;
+        const metadata = { ...config?.metadata };
+        const idMetadata = _getIdMetadata(metadata);
+        yield {
+            type: "task_result",
+            timestamp: ts,
+            step,
+            payload: {
+                id: uuid5(JSON.stringify([name, step, idMetadata]), TASK_NAMESPACE),
+                name,
+                result: writes.filter(([channel]) => streamChannelsList.includes(channel)),
+            },
+        };
+    }
+}
+export function* mapDebugCheckpoint(step, config, channels, streamChannels, metadata, tasks, pendingWrites) {
+    function formatConfig(config) {
+        // make sure the config is consistent with Python
+        const pyConfig = {};
+        if (config.callbacks != null)
+            pyConfig.callbacks = config.callbacks;
+        if (config.configurable != null)
+            pyConfig.configurable = config.configurable;
+        if (config.maxConcurrency != null)
+            pyConfig.max_concurrency = config.maxConcurrency;
+        if (config.metadata != null)
+            pyConfig.metadata = config.metadata;
+        if (config.recursionLimit != null)
+            pyConfig.recursion_limit = config.recursionLimit;
+        if (config.runId != null)
+            pyConfig.run_id = config.runId;
+        if (config.runName != null)
+            pyConfig.run_name = config.runName;
+        if (config.tags != null)
+            pyConfig.tags = config.tags;
+        return pyConfig;
+    }
+    function getCurrentUTC() {
+        const now = new Date();
+        return new Date(now.getTime() - now.getTimezoneOffset() * 60 * 1000);
+    }
+    const ts = getCurrentUTC().toISOString();
+    yield {
+        type: "checkpoint",
+        timestamp: ts,
+        step,
+        payload: {
+            config: formatConfig(config),
+            values: readChannels(channels, streamChannels),
+            metadata,
+            next: tasks.map((task) => task.name),
+            tasks: tasksWithWrites(tasks, pendingWrites),
+        },
+    };
+}
+export function tasksWithWrites(tasks, pendingWrites) {
+    return tasks.map((task) => {
+        const error = pendingWrites.find(([id, n]) => id === task.id && n === ERROR)?.[2];
+        if (error)
+            return { id: task.id, name: task.name, error };
+        return { id: task.id, name: task.name };
+    });
+}
+export function printStepCheckpoint(step, channels, whitelist) {
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:checkpoint]`)}`,
+        `\x1b[1m State at the end of step ${step}:\x1b[0m\n`,
+        JSON.stringify(readChannels(channels, whitelist), null, 2),
+    ].join(""));
+}
+export function printStepTasks(step, nextTasks) {
+    const nTasks = nextTasks.length;
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:tasks]`)}`,
+        `\x1b[1m Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}:\x1b[0m\n`,
+        nextTasks
+            .map((task) => `- ${wrap(COLORS_MAP.green, String(task.name))} -> ${JSON.stringify(task.input, null, 2)}`)
+            .join("\n"),
+    ].join(""));
+}
+export function printStepWrites(step, writes, whitelist) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const byChannel = {};
+    for (const [channel, value] of writes) {
+        if (whitelist.includes(channel)) {
+            if (!byChannel[channel]) {
+                byChannel[channel] = [];
+            }
+            byChannel[channel].push(value);
+        }
+    }
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:writes]`)}`,
+        `\x1b[1m Finished step ${step} with writes to ${Object.keys(byChannel).length} channel${Object.keys(byChannel).length !== 1 ? "s" : ""}:\x1b[0m\n`,
+        Object.entries(byChannel)
+            .map(([name, vals]) => `- ${wrap(COLORS_MAP.yellow, name)} -> ${vals
+            .map((v) => JSON.stringify(v))
+            .join(", ")}`)
+            .join("\n"),
+    ].join(""));
+}