@langchain/langgraph-api 1.1.2 → 1.1.8

package/dist/stream.mjs

@@ -1,235 +0,0 @@
-import { isBaseMessage } from "@langchain/core/messages";
-import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
-import { Client as LangSmithClient, getDefaultProjectName } from "langsmith";
-import { getLangGraphCommand } from "./command.mjs";
-import { checkLangGraphSemver } from "./semver/index.mjs";
-import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
-const isRunnableConfig = (config) => {
-    if (typeof config !== "object" || config == null)
-        return false;
-    return ("configurable" in config &&
-        typeof config.configurable === "object" &&
-        config.configurable != null);
-};
-function preprocessDebugCheckpointTask(task) {
-    if (!isRunnableConfig(task.state) ||
-        !taskRunnableConfigToCheckpoint(task.state)) {
-        return task;
-    }
-    const cloneTask = { ...task };
-    cloneTask.checkpoint = taskRunnableConfigToCheckpoint(task.state);
-    delete cloneTask.state;
-    return cloneTask;
-}
-const isConfigurablePresent = (config) => typeof config === "object" &&
-    config != null &&
-    "configurable" in config &&
-    typeof config.configurable === "object" &&
-    config.configurable != null;
-const deleteInternalConfigurableFields = (config) => {
-    if (isConfigurablePresent(config)) {
-        const newConfig = {
-            ...config,
-            configurable: Object.fromEntries(Object.entries(config.configurable).filter(([key]) => !key.startsWith("__"))),
-        };
-        delete newConfig.callbacks;
-        return newConfig;
-    }
-    return config;
-};
-function preprocessDebugCheckpoint(payload) {
-    const result = {
-        ...payload,
-        checkpoint: runnableConfigToCheckpoint(payload["config"]),
-        parent_checkpoint: runnableConfigToCheckpoint(payload["parentConfig"]),
-        tasks: payload["tasks"].map(preprocessDebugCheckpointTask),
-    };
-    // Handle LangGraph JS pascalCase vs snake_case
-    // TODO: use stream to LangGraph.JS
-    result.parent_config = payload["parentConfig"];
-    delete result.parentConfig;
-    result.config = deleteInternalConfigurableFields(result.config);
-    result.parent_config = deleteInternalConfigurableFields(result.parent_config);
-    return result;
-}
-let LANGGRAPH_VERSION;
-export async function* streamState(run, options) {
-    const kwargs = run.kwargs;
-    const graphId = kwargs.config?.configurable?.graph_id;
-    if (!graphId || typeof graphId !== "string") {
-        throw new Error("Invalid or missing graph_id");
-    }
-    const graph = await options.getGraph(graphId, kwargs.config, {
-        checkpointer: kwargs.temporary ? null : undefined,
-    });
-    const userStreamMode = kwargs.stream_mode ?? [];
-    const libStreamMode = new Set(userStreamMode.filter((mode) => mode !== "events" && mode !== "messages-tuple") ?? []);
-    if (userStreamMode.includes("messages-tuple")) {
-        libStreamMode.add("messages");
-    }
-    if (userStreamMode.includes("messages")) {
-        libStreamMode.add("values");
-    }
-    if (!libStreamMode.has("debug"))
-        libStreamMode.add("debug");
-    yield {
-        event: "metadata",
-        data: { run_id: run.run_id, attempt: options.attempt },
-    };
-    if (!LANGGRAPH_VERSION) {
-        const version = await checkLangGraphSemver();
-        LANGGRAPH_VERSION = version.find((v) => v.name === "@langchain/langgraph");
-    }
-    const metadata = {
-        ...kwargs.config?.metadata,
-        run_attempt: options.attempt,
-        langgraph_version: LANGGRAPH_VERSION?.version ?? "0.0.0",
-        langgraph_plan: "developer",
-        langgraph_host: "self-hosted",
-        langgraph_api_url: process.env.LANGGRAPH_API_URL ?? undefined,
-    };
-    const tracer = run.kwargs?.config?.configurable?.langsmith_project
-        ? new LangChainTracer({
-            replicas: [
-                [
-                    run.kwargs?.config?.configurable?.langsmith_project,
-                    {
-                        reference_example_id: run.kwargs?.config?.configurable?.langsmith_example_id,
-                    },
-                ],
-                [getDefaultProjectName(), undefined],
-            ],
-        })
-        : undefined;
-    const events = graph.streamEvents(kwargs.command != null
-        ? getLangGraphCommand(kwargs.command)
-        : kwargs.input ?? null, {
-        version: "v2",
-        interruptAfter: kwargs.interrupt_after,
-        interruptBefore: kwargs.interrupt_before,
-        tags: kwargs.config?.tags,
-        context: kwargs.context,
-        configurable: kwargs.config?.configurable,
-        recursionLimit: kwargs.config?.recursion_limit,
-        subgraphs: kwargs.subgraphs,
-        metadata,
-        runId: run.run_id,
-        streamMode: [...libStreamMode],
-        signal: options?.signal,
-        ...(tracer && { callbacks: [tracer] }),
-    });
-    const messages = {};
-    const completedIds = new Set();
-    for await (const event of events) {
-        if (event.tags?.includes("langsmith:hidden"))
-            continue;
-        if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
-            const [ns, mode, chunk] = (kwargs.subgraphs ? event.data.chunk : [null, ...event.data.chunk]);
-            // Listen for debug events and capture checkpoint
-            let data = chunk;
-            if (mode === "debug") {
-                const debugChunk = chunk;
-                if (debugChunk.type === "checkpoint") {
-                    const debugCheckpoint = preprocessDebugCheckpoint(debugChunk.payload);
-                    options?.onCheckpoint?.(debugCheckpoint);
-                    data = { ...debugChunk, payload: debugCheckpoint };
-                }
-                else if (debugChunk.type === "task_result") {
-                    const debugResult = preprocessDebugCheckpointTask(debugChunk.payload);
-                    options?.onTaskResult?.(debugResult);
-                    data = { ...debugChunk, payload: debugResult };
-                }
-            }
-            else if (mode === "checkpoints") {
-                const debugCheckpoint = preprocessDebugCheckpoint(chunk);
-                options?.onCheckpoint?.(debugCheckpoint);
-                data = debugCheckpoint;
-            }
-            else if (mode === "tasks") {
-                const debugTask = preprocessDebugCheckpointTask(chunk);
-                if ("result" in debugTask || "error" in debugTask) {
-                    options?.onTaskResult?.(debugTask);
-                }
-                data = debugTask;
-            }
-            if (mode === "messages") {
-                if (userStreamMode.includes("messages-tuple")) {
-                    if (kwargs.subgraphs && ns?.length) {
-                        yield { event: `messages|${ns.join("|")}`, data };
-                    }
-                    else {
-                        yield { event: "messages", data };
-                    }
-                }
-            }
-            else if (userStreamMode.includes(mode)) {
-                if (kwargs.subgraphs && ns?.length) {
-                    yield { event: `${mode}|${ns.join("|")}`, data };
-                }
-                else {
-                    yield { event: mode, data };
-                }
-            }
-        }
-        else if (userStreamMode.includes("events")) {
-            yield { event: "events", data: event };
-        }
-        // TODO: we still rely on old messages mode based of streamMode=values
-        // In order to fully switch to library messages mode, we need to do ensure that
-        // `StreamMessagesHandler` sends the final message, which requires the following:
-        // - handleLLMEnd does not send the final message b/c handleLLMNewToken sets the this.emittedChatModelRunIds[runId] flag. Python does not do that
-        // - handleLLMEnd receives the final message as BaseMessageChunk rather than BaseMessage, which from the outside will become indistinguishable.
-        // - handleLLMEnd should not dedupe the message
-        // - Don't think there's an utility that would convert a BaseMessageChunk to a BaseMessage?
-        if (userStreamMode.includes("messages")) {
-            if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
-                const newMessages = [];
-                const [_, chunk] = event.data.chunk;
-                let chunkMessages = [];
-                if (typeof chunk === "object" &&
-                    chunk != null &&
-                    "messages" in chunk &&
-                    !isBaseMessage(chunk)) {
-                    chunkMessages = chunk?.messages;
-                }
-                if (!Array.isArray(chunkMessages)) {
-                    chunkMessages = [chunkMessages];
-                }
-                for (const message of chunkMessages) {
-                    if (!message.id || completedIds.has(message.id))
-                        continue;
-                    completedIds.add(message.id);
-                    newMessages.push(message);
-                }
-                if (newMessages.length > 0) {
-                    yield { event: "messages/complete", data: newMessages };
-                }
-            }
-            else if (event.event === "on_chat_model_stream" &&
-                !event.tags?.includes("nostream")) {
-                const message = event.data.chunk;
-                if (!message.id)
-                    continue;
-                if (messages[message.id] == null) {
-                    messages[message.id] = message;
-                    yield {
-                        event: "messages/metadata",
-                        data: { [message.id]: { metadata: event.metadata } },
-                    };
-                }
-                else {
-                    messages[message.id] = messages[message.id].concat(message);
-                }
-                yield { event: "messages/partial", data: [messages[message.id]] };
-            }
-        }
-    }
-    if (kwargs.feedback_keys) {
-        const client = new LangSmithClient();
-        const data = Object.fromEntries(await Promise.all(kwargs.feedback_keys.map(async (feedback) => {
-            const { url } = await client.createPresignedFeedbackToken(run.run_id, feedback);
-            return [feedback, url];
-        })));
-        yield { event: "feedback", data };
-    }
-}

package/dist/ui/load.d.mts

@@ -1,8 +0,0 @@
-import { Hono } from "hono";
-export declare function registerGraphUi(defs: Record<string, string>, options: {
-    cwd: string;
-    config?: {
-        shared?: string[];
-    };
-}): Promise<void>;
-export declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/ui/load.mjs

@@ -1,53 +0,0 @@
-import { z } from "zod/v3";
-import { Hono } from "hono";
-import { getMimeType } from "hono/utils/mime";
-import { zValidator } from "@hono/zod-validator";
-import { watch } from "@langchain/langgraph-ui";
-import * as path from "node:path";
-const GRAPH_UI = {};
-export async function registerGraphUi(defs, options) {
-    await watch({
-        defs,
-        cwd: options.cwd,
-        config: options.config,
-        onOutput: (graphId, files) => (GRAPH_UI[graphId] = files),
-    });
-}
-export const api = new Hono();
-api.post("/ui/:agent", zValidator("json", z.object({ name: z.string() })), async (c) => {
-    const agent = c.req.param("agent");
-    const host = c.req.header("host");
-    const message = await c.req.valid("json");
-    const isHost = (needle) => {
-        if (!host)
-            return false;
-        return host.startsWith(needle + ":") || host === needle;
-    };
-    const protocol = isHost("localhost") || isHost("127.0.0.1") ? "http:" : "";
-    const files = GRAPH_UI[agent];
-    if (!files?.length)
-        return c.text(`UI not found for agent "${agent}"`, 404);
-    const messageName = JSON.stringify(message.name);
-    const result = [];
-    for (const css of files.filter((i) => path.extname(i.basename) === ".css")) {
-        result.push(`<link rel="stylesheet" href="${protocol}//${host}/ui/${agent}/${css.basename}" />`);
-    }
-    const stableName = agent.replace(/[^a-zA-Z0-9]/g, "_");
-    const js = files.find((i) => path.extname(i.basename) === ".js");
-    if (js) {
-        result.push(`<script src="${protocol}//${host}/ui/${agent}/${js.basename}" onload='__LGUI_${stableName}.render(${messageName}, "{{shadowRootId}}")'></script>`);
-    }
-    return c.text(result.join("\n"), {
-        headers: { "Content-Type": "text/html" },
-    });
-});
-api.get("/ui/:agent/:basename", async (c) => {
-    const agent = c.req.param("agent");
-    const basename = c.req.param("basename");
-    const file = GRAPH_UI[agent]?.find((item) => item.basename === basename);
-    if (!file)
-        return c.text("File not found", 404);
-    return c.body(file.contents, {
-        headers: { "Content-Type": getMimeType(file.basename) ?? "text/plain" },
-    });
-});

package/dist/utils/abort.d.mts

@@ -1 +0,0 @@
-export declare const combineAbortSignals: (...input: (AbortSignal | undefined | null)[]) => AbortSignal;

package/dist/utils/abort.mjs

@@ -1,8 +0,0 @@
-export const combineAbortSignals = (...input) => {
-    const signals = input.filter((item) => item != null);
-    if ("any" in AbortSignal)
-        return AbortSignal.any(signals);
-    const abortController = new AbortController();
-    signals.forEach((signal) => signal.addEventListener("abort", () => abortController.abort()));
-    return abortController.signal;
-};

package/dist/utils/hono.d.mts

@@ -1,5 +0,0 @@
-import type { Context } from "hono";
-import { StreamingApi } from "hono/utils/stream";
-export declare function jsonExtra<T>(c: Context, object: T): Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "body">;
-export declare function waitKeepAlive(c: Context, promise: Promise<unknown>): Response;
-export declare const getDisconnectAbortSignal: (c: Context, stream: StreamingApi) => AbortSignal;

package/dist/utils/hono.mjs

@@ -1,24 +0,0 @@
-import { serialiseAsDict } from "./serde.mjs";
-import { stream } from "hono/streaming";
-export function jsonExtra(c, object) {
-    c.header("Content-Type", "application/json");
-    return c.body(serialiseAsDict(object));
-}
-export function waitKeepAlive(c, promise) {
-    return stream(c, async (stream) => {
-        // keep sending newlines until we resolved the chunk
-        let keepAlive = Promise.resolve();
-        const timer = setInterval(() => {
-            keepAlive = keepAlive.then(() => stream.write("\n"));
-        }, 1000);
-        const result = await promise;
-        clearInterval(timer);
-        await keepAlive;
-        await stream.write(serialiseAsDict(result));
-    });
-}
-export const getDisconnectAbortSignal = (c, stream) => {
-    // https://github.com/honojs/hono/issues/1770
-    stream.onAbort(() => { });
-    return c.req.raw.signal;
-};

package/dist/utils/importMap.d.mts

@@ -1,55 +0,0 @@
-import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate } from "@langchain/core/prompts";
-import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk } from "@langchain/core/messages";
-import { StringPromptValue } from "@langchain/core/prompt_values";
-export declare const prompts__prompt: {
-    PromptTemplate: typeof PromptTemplate;
-};
-export declare const schema__messages: {
-    AIMessage: typeof AIMessage;
-    AIMessageChunk: typeof AIMessageChunk;
-    BaseMessage: typeof BaseMessage;
-    BaseMessageChunk: typeof BaseMessageChunk;
-    ChatMessage: typeof ChatMessage;
-    ChatMessageChunk: typeof ChatMessageChunk;
-    FunctionMessage: typeof FunctionMessage;
-    FunctionMessageChunk: typeof FunctionMessageChunk;
-    HumanMessage: typeof HumanMessage;
-    HumanMessageChunk: typeof HumanMessageChunk;
-    SystemMessage: typeof SystemMessage;
-    SystemMessageChunk: typeof SystemMessageChunk;
-    ToolMessage: typeof ToolMessage;
-    ToolMessageChunk: typeof ToolMessageChunk;
-};
-export declare const schema: {
-    AIMessage: typeof AIMessage;
-    AIMessageChunk: typeof AIMessageChunk;
-    BaseMessage: typeof BaseMessage;
-    BaseMessageChunk: typeof BaseMessageChunk;
-    ChatMessage: typeof ChatMessage;
-    ChatMessageChunk: typeof ChatMessageChunk;
-    FunctionMessage: typeof FunctionMessage;
-    FunctionMessageChunk: typeof FunctionMessageChunk;
-    HumanMessage: typeof HumanMessage;
-    HumanMessageChunk: typeof HumanMessageChunk;
-    SystemMessage: typeof SystemMessage;
-    SystemMessageChunk: typeof SystemMessageChunk;
-    ToolMessage: typeof ToolMessage;
-    ToolMessageChunk: typeof ToolMessageChunk;
-};
-export declare const prompts__chat: {
-    AIMessagePromptTemplate: typeof AIMessagePromptTemplate;
-    ChatMessagePromptTemplate: typeof ChatMessagePromptTemplate;
-    ChatPromptTemplate: typeof ChatPromptTemplate;
-    HumanMessagePromptTemplate: typeof HumanMessagePromptTemplate;
-    MessagesPlaceholder: typeof MessagesPlaceholder;
-    SystemMessagePromptTemplate: typeof SystemMessagePromptTemplate;
-};
-export declare const prompts__image: {
-    ImagePromptTemplate: typeof ImagePromptTemplate;
-};
-export declare const prompts__pipeline: {
-    PipelinePromptTemplate: typeof PipelinePromptTemplate;
-};
-export declare const prompts__base: {
-    StringPromptValue: typeof StringPromptValue;
-};

package/dist/utils/importMap.mjs

@@ -1,55 +0,0 @@
-import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate, } from "@langchain/core/prompts";
-import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, } from "@langchain/core/messages";
-import { StringPromptValue } from "@langchain/core/prompt_values";
-export const prompts__prompt = {
-    PromptTemplate,
-};
-export const schema__messages = {
-    AIMessage,
-    AIMessageChunk,
-    BaseMessage,
-    BaseMessageChunk,
-    ChatMessage,
-    ChatMessageChunk,
-    FunctionMessage,
-    FunctionMessageChunk,
-    HumanMessage,
-    HumanMessageChunk,
-    SystemMessage,
-    SystemMessageChunk,
-    ToolMessage,
-    ToolMessageChunk,
-};
-export const schema = {
-    AIMessage,
-    AIMessageChunk,
-    BaseMessage,
-    BaseMessageChunk,
-    ChatMessage,
-    ChatMessageChunk,
-    FunctionMessage,
-    FunctionMessageChunk,
-    HumanMessage,
-    HumanMessageChunk,
-    SystemMessage,
-    SystemMessageChunk,
-    ToolMessage,
-    ToolMessageChunk,
-};
-export const prompts__chat = {
-    AIMessagePromptTemplate,
-    ChatMessagePromptTemplate,
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    MessagesPlaceholder,
-    SystemMessagePromptTemplate,
-};
-export const prompts__image = {
-    ImagePromptTemplate,
-};
-export const prompts__pipeline = {
-    PipelinePromptTemplate,
-};
-export const prompts__base = {
-    StringPromptValue,
-};

package/dist/utils/runnableConfig.d.mts

@@ -1,3 +0,0 @@
-import type { Checkpoint, RunnableConfig } from "../storage/types.mjs";
-export declare const runnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Checkpoint | null;
-export declare const taskRunnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Partial<Checkpoint> | null;

package/dist/utils/runnableConfig.mjs

@@ -1,45 +0,0 @@
-import { z } from "zod/v3";
-const ConfigSchema = z.object({
-    configurable: z.object({
-        thread_id: z.string(),
-        checkpoint_id: z.string(),
-        checkpoint_ns: z.string().nullish(),
-        checkpoint_map: z.record(z.string(), z.unknown()).nullish(),
-    }),
-});
-export const runnableConfigToCheckpoint = (config) => {
-    if (!config || !config.configurable || !config.configurable.thread_id) {
-        return null;
-    }
-    const parsed = ConfigSchema.safeParse(config);
-    if (!parsed.success)
-        return null;
-    return {
-        thread_id: parsed.data.configurable.thread_id,
-        checkpoint_id: parsed.data.configurable.checkpoint_id,
-        checkpoint_ns: parsed.data.configurable.checkpoint_ns || "",
-        checkpoint_map: parsed.data.configurable.checkpoint_map || null,
-    };
-};
-const TaskConfigSchema = z.object({
-    configurable: z.object({
-        thread_id: z.string(),
-        checkpoint_id: z.string().nullish(),
-        checkpoint_ns: z.string().nullish(),
-        checkpoint_map: z.record(z.string(), z.unknown()).nullish(),
-    }),
-});
-export const taskRunnableConfigToCheckpoint = (config) => {
-    if (!config || !config.configurable || !config.configurable.thread_id) {
-        return null;
-    }
-    const parsed = TaskConfigSchema.safeParse(config);
-    if (!parsed.success)
-        return null;
-    return {
-        thread_id: parsed.data.configurable.thread_id,
-        checkpoint_id: parsed.data.configurable.checkpoint_id || null,
-        checkpoint_ns: parsed.data.configurable.checkpoint_ns || "",
-        checkpoint_map: parsed.data.configurable.checkpoint_map || null,
-    };
-};

package/dist/utils/serde.d.mts

@@ -1,5 +0,0 @@
-export declare const serialiseAsDict: (obj: unknown) => string;
-export declare const serializeError: (error: unknown) => {
-    error: string;
-    message: string;
-};

package/dist/utils/serde.mjs

@@ -1,20 +0,0 @@
-export const serialiseAsDict = (obj) => {
-    return JSON.stringify(obj, function (key, value) {
-        const rawValue = this[key];
-        if (rawValue != null &&
-            typeof rawValue === "object" &&
-            "toDict" in rawValue &&
-            typeof rawValue.toDict === "function") {
-            // TODO: we need to upstream this to LangChainJS
-            const { type, data } = rawValue.toDict();
-            return { ...data, type };
-        }
-        return value;
-    }, 2);
-};
-export const serializeError = (error) => {
-    if (error instanceof Error) {
-        return { error: error.name, message: error.message };
-    }
-    return { error: "Error", message: JSON.stringify(error) };
-};

package/dist/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vitest/config").UserConfigFnObject;
-export default _default;

package/dist/vitest.config.js

@@ -1,12 +0,0 @@
-import { configDefaults, defineConfig } from "vitest/config";
-import { nodePolyfills } from "vite-plugin-node-polyfills";
-export default defineConfig(() => {
-    /** @type {import("vitest/config").UserConfigExport} */
-    return {
-        test: {
-            hideSkippedTests: true,
-            testTimeout: 30_000,
-            fileParallelism: false,
-        },
-    };
-});

package/dist/webhook.d.mts

@@ -1,11 +0,0 @@
-import type { Run } from "./storage/types.mjs";
-import type { StreamCheckpoint } from "./stream.mjs";
-export declare function callWebhook(result: {
-    checkpoint: StreamCheckpoint | undefined;
-    status: string | undefined;
-    exception: Error | undefined;
-    run: Run;
-    webhook: string;
-    run_started_at: Date;
-    run_ended_at: Date | undefined;
-}): Promise<void>;

package/dist/webhook.mjs

@@ -1,30 +0,0 @@
-import { serializeError } from "./utils/serde.mjs";
-import { getLoopbackFetch } from "./loopback.mjs";
-export async function callWebhook(result) {
-    const payload = {
-        ...result.run,
-        status: result.status,
-        run_started_at: result.run_started_at.toISOString(),
-        run_ended_at: result.run_ended_at?.toISOString(),
-        webhook_sent_at: new Date().toISOString(),
-        values: result.checkpoint?.values,
-        ...(result.exception
-            ? { error: serializeError(result.exception).message }
-            : undefined),
-    };
-    if (result.webhook.startsWith("/")) {
-        const fetch = getLoopbackFetch();
-        if (!fetch)
-            throw new Error("Loopback fetch is not bound");
-        await fetch(result.webhook, {
-            method: "POST",
-            body: JSON.stringify(payload),
-        });
-    }
-    else {
-        await fetch(result.webhook, {
-            method: "POST",
-            body: JSON.stringify(payload),
-        });
-    }
-}