@langchain/langgraph-api 1.1.2 → 1.1.8

package/dist/graph/parser/schema/types.template.d.mts

@@ -1 +0,0 @@
-export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

package/dist/graph/parser/schema/types.template.mts

@@ -1,92 +0,0 @@
-import type { BaseMessage } from "@langchain/core/messages";
-import type {
-  StateType,
-  UpdateType,
-  StateDefinition,
-} from "@langchain/langgraph";
-
-// @ts-ignore
-type AnyPregel = {
-  lg_is_pregel: boolean;
-  stream: (...args: any[]) => any;
-  invoke: (...args: any[]) => any;
-};
-
-// @ts-ignore
-type AnyGraph = {
-  compiled: boolean;
-  compile: (...args: any[]) => any;
-};
-
-export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
-  T
->() => T extends Y ? 1 : 2
-  ? true
-  : false;
-
-type MatchBaseMessage<T> = T extends BaseMessage ? BaseMessage : never;
-type MatchBaseMessageArray<T> = T extends Array<infer C>
-  ? Equals<MatchBaseMessage<C>, BaseMessage> extends true
-    ? BaseMessage[]
-    : never
-  : never;
-
-type Defactorify<T> = T extends (...args: any[]) => infer R
-  ? Awaited<R>
-  : Awaited<T>;
-
-// @ts-ignore
-type Inspect<T, TDepth extends Array<0> = []> = TDepth extends [0, 0, 0]
-  ? any
-  : T extends unknown
-  ? {
-      [K in keyof T]: 0 extends 1 & T[K]
-        ? T[K]
-        : Equals<MatchBaseMessageArray<T[K]>, BaseMessage[]> extends true
-        ? BaseMessage[]
-        : Equals<MatchBaseMessage<T[K]>, BaseMessage> extends true
-        ? BaseMessage
-        : Inspect<T[K], [0, ...TDepth]>;
-    }
-  : never;
-
-type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
-  ? { state: S; update: U }
-  : T extends { "~InputType": infer InputType; "~OutputType": infer OutputType }
-  ? { state: OutputType; update: InputType }
-  : never;
-
-// @ts-ignore
-type Reflect<T> = Defactorify<T> extends infer DT
-  ? DT extends {
-      compile(...args: any[]): infer Compiled;
-    }
-    ? ReflectCompiled<Compiled>
-    : ReflectCompiled<DT>
-  : never;
-
-type BuilderReflectCompiled<T> = T extends {
-  builder: {
-    _inputDefinition: infer I extends StateDefinition;
-    _outputDefinition: infer O extends StateDefinition;
-    _configSchema?: infer C extends StateDefinition | undefined;
-  };
-}
-  ? {
-      input: UpdateType<I>;
-      output: StateType<O>;
-      config: UpdateType<Exclude<C, undefined>>;
-    }
-  : never;
-
-// @ts-ignore
-type BuilderReflect<T> = Defactorify<T> extends infer DT
-  ? DT extends {
-      compile(...args: any[]): infer Compiled;
-    }
-    ? BuilderReflectCompiled<Compiled>
-    : BuilderReflectCompiled<DT>
-  : never;
-
-// @ts-ignore
-type FilterAny<T> = 0 extends 1 & T ? never : T;

package/dist/http/custom.d.mts

@@ -1,6 +0,0 @@
-import { Hono } from "hono";
-export declare function registerHttp(appPath: string, options: {
-    cwd: string;
-}): Promise<{
-    api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-}>;

package/dist/http/custom.mjs

@@ -1,10 +0,0 @@
-import * as path from "node:path";
-import * as url from "node:url";
-export async function registerHttp(appPath, options) {
-    const [userFile, exportSymbol] = appPath.split(":", 2);
-    const sourceFile = path.resolve(options.cwd, userFile);
-    const user = (await import(url.pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]));
-    if (!user)
-        throw new Error(`Failed to load HTTP app: ${appPath}`);
-    return { api: user };
-}

package/dist/http/middleware.d.mts

@@ -1,11 +0,0 @@
-import { MiddlewareHandler } from "hono";
-export declare const cors: (cors: {
-    allow_origins?: string[];
-    allow_origin_regex?: string;
-    allow_methods?: string[];
-    allow_headers?: string[];
-    allow_credentials?: boolean;
-    expose_headers?: string[];
-    max_age?: number;
-} | undefined) => MiddlewareHandler;
-export declare const ensureContentType: () => MiddlewareHandler;

package/dist/http/middleware.mjs

@@ -1,57 +0,0 @@
-import { cors as honoCors } from "hono/cors";
-export const cors = (cors) => {
-    if (cors == null) {
-        return honoCors({
-            origin: "*",
-            exposeHeaders: ["content-location", "x-pagination-total"],
-        });
-    }
-    const originRegex = cors.allow_origin_regex
-        ? new RegExp(cors.allow_origin_regex)
-        : undefined;
-    const origin = originRegex
-        ? (origin) => {
-            originRegex.lastIndex = 0; // reset regex in case it's a global regex
-            if (originRegex.test(origin))
-                return origin;
-            return undefined;
-        }
-        : cors.allow_origins;
-    if (cors.expose_headers?.length) {
-        const headersSet = new Set(cors.expose_headers.map((h) => h.toLowerCase()));
-        if (!headersSet.has("content-location")) {
-            console.warn("Adding missing `Content-Location` header in `cors.expose_headers`.");
-            cors.expose_headers.push("content-location");
-        }
-        if (!headersSet.has("x-pagination-total")) {
-            console.warn("Adding missing `X-Pagination-Total` header in `cors.expose_headers`.");
-            cors.expose_headers.push("x-pagination-total");
-        }
-    }
-    const config = { origin: origin ?? "*" };
-    if (cors.max_age != null)
-        config.maxAge = cors.max_age;
-    if (cors.allow_methods != null)
-        config.allowMethods = cors.allow_methods;
-    if (cors.allow_headers != null)
-        config.allowHeaders = cors.allow_headers;
-    if (cors.expose_headers != null)
-        config.exposeHeaders = cors.expose_headers;
-    if (cors.allow_credentials != null) {
-        config.credentials = cors.allow_credentials;
-    }
-    return honoCors(config);
-};
-// This is used to match the behavior of the original LangGraph API
-// where the content-type is not being validated. Might be nice
-// to warn about this in the future and throw an error instead.
-export const ensureContentType = () => {
-    return async (c, next) => {
-        if (c.req.header("content-type")?.startsWith("text/plain") &&
-            c.req.method !== "GET" &&
-            c.req.method !== "OPTIONS") {
-            c.req.raw.headers.set("content-type", "application/json");
-        }
-        await next();
-    };
-};

package/dist/logging.d.mts

@@ -1,10 +0,0 @@
-import { type Logger } from "winston";
-import type { MiddlewareHandler } from "hono";
-export declare const logger: Logger;
-export declare function registerSdkLogger(): void;
-export declare function registerRuntimeLogFormatter(formatter: (info: Record<string, unknown>) => Record<string, unknown>): Promise<void>;
-export declare const logError: (error: unknown, options?: {
-    context?: Record<string, unknown>;
-    prefix?: string;
-}) => void;
-export declare const requestLogger: () => MiddlewareHandler;

package/dist/logging.mjs

@@ -1,115 +0,0 @@
-import { createLogger, format, transports } from "winston";
-import { logger as honoLogger } from "hono/logger";
-import { consoleFormat } from "winston-console-format";
-import { parse as stacktraceParser } from "stacktrace-parser";
-import { readFileSync } from "node:fs";
-import { codeFrameColumns } from "@babel/code-frame";
-import path from "node:path";
-const LOG_JSON = process.env.LOG_JSON === "true";
-const LOG_LEVEL = process.env.LOG_LEVEL || "debug";
-let RUNTIME_LOG_FORMATTER;
-const applyRuntimeFormatter = format((info) => {
-    if (!RUNTIME_LOG_FORMATTER)
-        return info;
-    return RUNTIME_LOG_FORMATTER(info);
-});
-export const logger = createLogger({
-    level: LOG_LEVEL,
-    format: format.combine(applyRuntimeFormatter(), format.errors({ stack: true }), format.timestamp(), format.json(), ...(!LOG_JSON
-        ? [
-            format.colorize({ all: true }),
-            format.padLevels(),
-            consoleFormat({
-                showMeta: true,
-                metaStrip: ["timestamp"],
-                inspectOptions: {
-                    depth: Infinity,
-                    colors: true,
-                    maxArrayLength: Infinity,
-                    breakLength: 120,
-                    compact: Infinity,
-                },
-            }),
-        ]
-        : [
-            format.printf((info) => {
-                const { timestamp, level, message, ...rest } = info;
-                let event;
-                if (typeof message === "string") {
-                    event = message;
-                }
-                else {
-                    event = JSON.stringify(message);
-                }
-                if (rest.stack) {
-                    rest.message = event;
-                    event = rest.stack;
-                }
-                return JSON.stringify({ timestamp, level, event, ...rest });
-            }),
-        ])),
-    transports: [new transports.Console()],
-});
-// Expose the logger to be consumed by `getLogger`
-export function registerSdkLogger() {
-    const GLOBAL_LOGGER = Symbol.for("langgraph.api.sdk-logger");
-    const maybeGlobal = globalThis;
-    maybeGlobal[GLOBAL_LOGGER] = logger;
-}
-export async function registerRuntimeLogFormatter(formatter) {
-    RUNTIME_LOG_FORMATTER = formatter;
-}
-const formatStack = (stack) => {
-    if (!stack)
-        return stack;
-    const [firstFile] = stacktraceParser(stack).filter((item) => !item.file?.split(path.sep).includes("node_modules") &&
-        !item.file?.startsWith("node:"));
-    if (firstFile?.file && firstFile?.lineNumber) {
-        try {
-            const filePath = firstFile.file;
-            const line = firstFile.lineNumber;
-            const column = firstFile.column ?? 0;
-            const messageLines = stack.split("\n");
-            const spliceIndex = messageLines.findIndex((i) => i.includes(filePath));
-            const padding = " ".repeat(Math.max(0, messageLines[spliceIndex].indexOf("at")));
-            const highlightCode = process.stdout.isTTY;
-            let codeFrame = codeFrameColumns(readFileSync(filePath, "utf-8"), { start: { line, column } }, { highlightCode });
-            codeFrame = codeFrame
-                .split("\n")
-                .map((i) => padding + i + "\x1b[0m")
-                .join("\n");
-            if (highlightCode) {
-                codeFrame = "\x1b[36m" + codeFrame + "\x1b[31m";
-            }
-            // insert codeframe after the line but dont lose the stack
-            return [
-                ...messageLines.slice(0, spliceIndex + 1),
-                codeFrame,
-                ...messageLines.slice(spliceIndex + 1),
-            ].join("\n");
-        }
-        catch {
-            // pass
-        }
-    }
-    return stack;
-};
-export const logError = (error, options) => {
-    let message;
-    let context = options?.context;
-    if (error instanceof Error) {
-        message = formatStack(error.stack) || error.message;
-    }
-    else {
-        message = String(error);
-        context = { ...context, error };
-    }
-    if (options?.prefix != null)
-        message = `${options.prefix}:\n${message}`;
-    logger.error(message, ...(context != null ? [context] : []));
-};
-process.on("uncaughtException", (error) => logError(error));
-process.on("unhandledRejection", (error) => logError(error));
-export const requestLogger = () => honoLogger((message, ...rest) => {
-    logger.info(message, ...rest);
-});

package/dist/loopback.d.mts

@@ -1,4 +0,0 @@
-import { Hono } from "hono";
-import type { StorageEnv } from "./storage/types.mjs";
-export declare function getLoopbackFetch(): (url: string, init?: RequestInit) => Promise<Response>;
-export declare const bindLoopbackFetch: (app: Hono<StorageEnv>) => void;

package/dist/loopback.mjs

@@ -1,10 +0,0 @@
-const fetchSmb = Symbol.for("langgraph_api:fetch");
-const global = globalThis;
-export function getLoopbackFetch() {
-    if (!global[fetchSmb])
-        throw new Error("Loopback fetch is not bound");
-    return global[fetchSmb];
-}
-export const bindLoopbackFetch = (app) => {
-    global[fetchSmb] = async (url, init) => app.request(url, init);
-};

package/dist/preload.d.mts

@@ -1 +0,0 @@
-export {};

package/dist/preload.mjs

@@ -1,29 +0,0 @@
-import { register } from "node:module";
-import { pathToFileURL } from "node:url";
-import { join } from "node:path";
-// arguments passed to the entrypoint: [ppid, payload]
-// we only care about the payload, which contains the server definition
-const lastArg = process.argv.at(-1);
-const options = JSON.parse(lastArg || "{}");
-// find the first file, as `parentURL` needs to be a valid file URL
-// if no graph found, just assume a dummy default file, which should
-// be working fine as well.
-const graphFiles = Object.values(options.graphs)
-    .map((i) => {
-    if (typeof i === "string") {
-        return i.split(":").at(0);
-    }
-    else if (i && typeof i === "object" && i.path) {
-        return i.path.split(":").at(0);
-    }
-    return null;
-})
-    .filter(Boolean);
-const firstGraphFile = graphFiles.at(0) || "index.mts";
-// enforce API @langchain/langgraph resolution
-register("./graph/load.hooks.mjs", import.meta.url, {
-    parentURL: "data:",
-    data: {
-        parentURL: pathToFileURL(join(options.cwd, firstGraphFile)).toString(),
-    },
-});

package/dist/queue.d.mts

@@ -1,2 +0,0 @@
-import type { Ops } from "./storage/types.mjs";
-export declare const queue: (ops: Ops) => Promise<never>;

package/dist/queue.mjs

@@ -1,119 +0,0 @@
-import { streamState, } from "./stream.mjs";
-import { logError, logger } from "./logging.mjs";
-import { serializeError } from "./utils/serde.mjs";
-import { callWebhook } from "./webhook.mjs";
-import { getGraph } from "./graph/load.mjs";
-const MAX_RETRY_ATTEMPTS = 3;
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export const queue = async (ops) => {
-    while (true) {
-        for await (const { run, attempt, signal } of ops.runs.next()) {
-            await worker(ops, run, attempt, signal);
-        }
-        // TODO: this is very suboptimal, we should implement subscription to the run
-        await sleep(1000 * Math.random());
-    }
-};
-const worker = async (ops, run, attempt, signal) => {
-    const startedAt = new Date();
-    let endedAt = undefined;
-    let checkpoint = undefined;
-    let exception = undefined;
-    let status = undefined;
-    const temporary = run.kwargs.temporary;
-    const webhook = run.kwargs.webhook;
-    logger.info("Starting background run", {
-        run_id: run.run_id,
-        run_attempt: attempt,
-        run_created_at: run.created_at,
-        run_started_at: startedAt,
-        run_queue_ms: startedAt.valueOf() - run.created_at.valueOf(),
-    });
-    const onCheckpoint = (value) => {
-        checkpoint = value;
-    };
-    const onTaskResult = (result) => {
-        if (checkpoint == null)
-            return;
-        const index = checkpoint.tasks.findIndex((task) => task.id === result.id);
-        checkpoint.tasks[index] = {
-            ...checkpoint.tasks[index],
-            ...result,
-        };
-    };
-    try {
-        if (attempt > MAX_RETRY_ATTEMPTS) {
-            throw new Error(`Run ${run.run_id} exceeded max attempts`);
-        }
-        const runId = run.run_id;
-        const resumable = run.kwargs?.resumable ?? false;
-        try {
-            const stream = streamState(run, {
-                getGraph,
-                attempt,
-                signal,
-                ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
-            });
-            for await (const { event, data } of stream) {
-                await ops.runs.stream.publish({ runId, resumable, event, data });
-            }
-        }
-        catch (error) {
-            await ops.runs.stream.publish({
-                runId,
-                resumable,
-                event: "error",
-                data: serializeError(error),
-            });
-            throw error;
-        }
-        endedAt = new Date();
-        logger.info("Background run succeeded", {
-            run_id: run.run_id,
-            run_attempt: attempt,
-            run_created_at: run.created_at,
-            run_started_at: startedAt,
-            run_ended_at: endedAt,
-            run_exec_ms: endedAt.valueOf() - startedAt.valueOf(),
-        });
-        status = "success";
-        await ops.runs.setStatus(run.run_id, status);
-    }
-    catch (error) {
-        endedAt = new Date();
-        if (error instanceof Error)
-            exception = error;
-        logError(error, {
-            prefix: "Background run failed",
-            context: {
-                run_id: run.run_id,
-                run_attempt: attempt,
-                run_created_at: run.created_at,
-                run_started_at: startedAt,
-                run_ended_at: endedAt,
-                run_exec_ms: endedAt.valueOf() - startedAt.valueOf(),
-            },
-        });
-        status = "error";
-        await ops.runs.setStatus(run.run_id, "error");
-    }
-    finally {
-        if (temporary) {
-            await ops.threads.delete(run.thread_id, undefined);
-        }
-        else {
-            await ops.threads.setStatus(run.thread_id, { checkpoint, exception });
-        }
-        if (webhook) {
-            await callWebhook({
-                checkpoint,
-                status,
-                exception,
-                run,
-                webhook,
-                run_started_at: startedAt,
-                run_ended_at: endedAt,
-            });
-        }
-    }
-};