@langchain/langgraph-api 1.1.1 → 1.1.8

package/dist/server.d.mts

@@ -1,175 +0,0 @@
-import type { Ops } from "./storage/types.mjs";
-import { z } from "zod/v3";
-export declare const StartServerSchema: z.ZodObject<{
-    port: z.ZodNumber;
-    nWorkers: z.ZodNumber;
-    host: z.ZodString;
-    cwd: z.ZodString;
-    graphs: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        description?: string | undefined;
-    }, {
-        path: string;
-        description?: string | undefined;
-    }>]>>;
-    auth: z.ZodOptional<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        disable_studio_auth: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        disable_studio_auth: boolean;
-        path?: string | undefined;
-    }, {
-        path?: string | undefined;
-        disable_studio_auth?: boolean | undefined;
-    }>>;
-    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    ui_config: z.ZodOptional<z.ZodObject<{
-        shared: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        shared?: string[] | undefined;
-    }, {
-        shared?: string[] | undefined;
-    }>>;
-    http: z.ZodOptional<z.ZodObject<{
-        app: z.ZodOptional<z.ZodString>;
-        disable_assistants: z.ZodDefault<z.ZodBoolean>;
-        disable_threads: z.ZodDefault<z.ZodBoolean>;
-        disable_runs: z.ZodDefault<z.ZodBoolean>;
-        disable_store: z.ZodDefault<z.ZodBoolean>;
-        disable_meta: z.ZodDefault<z.ZodBoolean>;
-        cors: z.ZodOptional<z.ZodObject<{
-            allow_origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            allow_methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            allow_headers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            allow_credentials: z.ZodOptional<z.ZodBoolean>;
-            allow_origin_regex: z.ZodOptional<z.ZodString>;
-            expose_headers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            max_age: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        }, {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        disable_assistants: boolean;
-        disable_threads: boolean;
-        disable_runs: boolean;
-        disable_store: boolean;
-        disable_meta: boolean;
-        cors?: {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        } | undefined;
-        app?: string | undefined;
-    }, {
-        cors?: {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        } | undefined;
-        app?: string | undefined;
-        disable_assistants?: boolean | undefined;
-        disable_threads?: boolean | undefined;
-        disable_runs?: boolean | undefined;
-        disable_store?: boolean | undefined;
-        disable_meta?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    cwd: string;
-    host: string;
-    port: number;
-    nWorkers: number;
-    graphs: Record<string, string | {
-        path: string;
-        description?: string | undefined;
-    }>;
-    auth?: {
-        disable_studio_auth: boolean;
-        path?: string | undefined;
-    } | undefined;
-    ui?: Record<string, string> | undefined;
-    ui_config?: {
-        shared?: string[] | undefined;
-    } | undefined;
-    http?: {
-        disable_assistants: boolean;
-        disable_threads: boolean;
-        disable_runs: boolean;
-        disable_store: boolean;
-        disable_meta: boolean;
-        cors?: {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        } | undefined;
-        app?: string | undefined;
-    } | undefined;
-}, {
-    cwd: string;
-    host: string;
-    port: number;
-    nWorkers: number;
-    graphs: Record<string, string | {
-        path: string;
-        description?: string | undefined;
-    }>;
-    auth?: {
-        path?: string | undefined;
-        disable_studio_auth?: boolean | undefined;
-    } | undefined;
-    ui?: Record<string, string> | undefined;
-    ui_config?: {
-        shared?: string[] | undefined;
-    } | undefined;
-    http?: {
-        cors?: {
-            allow_origin_regex?: string | undefined;
-            expose_headers?: string[] | undefined;
-            max_age?: number | undefined;
-            allow_methods?: string[] | undefined;
-            allow_headers?: string[] | undefined;
-            allow_credentials?: boolean | undefined;
-            allow_origins?: string[] | undefined;
-        } | undefined;
-        app?: string | undefined;
-        disable_assistants?: boolean | undefined;
-        disable_threads?: boolean | undefined;
-        disable_runs?: boolean | undefined;
-        disable_store?: boolean | undefined;
-        disable_meta?: boolean | undefined;
-    } | undefined;
-}>;
-export declare function startServer(options: z.infer<typeof StartServerSchema>, storage?: {
-    ops?: Ops;
-}): Promise<{
-    host: string;
-    cleanup: () => Promise<void>;
-}>;

package/dist/server.mjs

@@ -1,181 +0,0 @@
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-import { contextStorage } from "hono/context-storage";
-import { registerFromEnv } from "./graph/load.mjs";
-import runs from "./api/runs.mjs";
-import threads from "./api/threads.mjs";
-import assistants from "./api/assistants.mjs";
-import store from "./api/store.mjs";
-import meta from "./api/meta.mjs";
-import { zValidator } from "@hono/zod-validator";
-import { z } from "zod/v3";
-import { queue } from "./queue.mjs";
-import { logger, requestLogger, registerRuntimeLogFormatter, registerSdkLogger, } from "./logging.mjs";
-import { checkpointer } from "./storage/checkpoint.mjs";
-import { FileSystemOps } from "./storage/ops.mjs";
-import { store as graphStore } from "./storage/store.mjs";
-import { auth } from "./auth/custom.mjs";
-import { registerAuth } from "./auth/index.mjs";
-import { registerHttp } from "./http/custom.mjs";
-import { cors, ensureContentType } from "./http/middleware.mjs";
-import { bindLoopbackFetch } from "./loopback.mjs";
-import { checkLangGraphSemver } from "./semver/index.mjs";
-import { getConfig } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./storage/persist.mjs";
-export const StartServerSchema = z.object({
-    port: z.number(),
-    nWorkers: z.number(),
-    host: z.string(),
-    cwd: z.string(),
-    graphs: z.record(z.union([
-        z.string(),
-        z.object({ path: z.string(), description: z.string().optional() }),
-    ])),
-    auth: z
-        .object({
-        path: z.string().optional(),
-        disable_studio_auth: z.boolean().default(false),
-    })
-        .optional(),
-    ui: z.record(z.string()).optional(),
-    ui_config: z.object({ shared: z.array(z.string()).optional() }).optional(),
-    http: z
-        .object({
-        app: z.string().optional(),
-        disable_assistants: z.boolean().default(false),
-        disable_threads: z.boolean().default(false),
-        disable_runs: z.boolean().default(false),
-        disable_store: z.boolean().default(false),
-        disable_meta: z.boolean().default(false),
-        cors: z
-            .object({
-            allow_origins: z.array(z.string()).optional(),
-            allow_methods: z.array(z.string()).optional(),
-            allow_headers: z.array(z.string()).optional(),
-            allow_credentials: z.boolean().optional(),
-            allow_origin_regex: z.string().optional(),
-            expose_headers: z.array(z.string()).optional(),
-            max_age: z.number().optional(),
-        })
-            .optional(),
-    })
-        .optional(),
-});
-export async function startServer(options, storage) {
-    const semver = await checkLangGraphSemver();
-    const invalidPackages = semver.filter((s) => !s.satisfies);
-    if (invalidPackages.length > 0) {
-        logger.warn(`Some LangGraph.js dependencies are not up to date. Please make sure to update them to the required version.`, Object.fromEntries(invalidPackages.map(({ name, version, required }) => [
-            name,
-            { version, required },
-        ])));
-    }
-    logger.info(`Initializing storage...`);
-    let initCalls = [
-        checkpointer.initialize(options.cwd),
-        graphStore.initialize(options.cwd),
-    ];
-    let ops = storage?.ops;
-    if (ops == null) {
-        const opsConn = new FileSystemPersistence(".langgraphjs_ops.json", () => ({
-            runs: {},
-            threads: {},
-            assistants: {},
-            assistant_versions: [],
-            retry_counter: {},
-        }));
-        initCalls.push(opsConn.initialize(options.cwd));
-        ops = new FileSystemOps(opsConn);
-    }
-    const callbacks = await Promise.all(initCalls);
-    const cleanup = async () => {
-        logger.info(`Flushing to persistent storage, exiting...`);
-        await Promise.all(callbacks.map((c) => c.flush()));
-    };
-    // Register global logger that can be consumed via SDK
-    // We need to do this before we load the graphs in-case the logger is obtained at top-level.
-    registerSdkLogger();
-    logger.info(`Registering graphs from ${options.cwd}`);
-    let hasGraphDescriptions = false;
-    const graphPaths = Object.fromEntries(Object.entries(options.graphs).map(([graphId, rawSpec]) => {
-        if (typeof rawSpec === "string") {
-            return [graphId, rawSpec];
-        }
-        if (rawSpec.description) {
-            hasGraphDescriptions = true;
-        }
-        return [graphId, rawSpec.path];
-    }));
-    if (hasGraphDescriptions) {
-        logger.warn("A graph definition in `langgraph.json` has a `description` property. Local MCP features are not yet supported with the JS CLI and will be ignored.");
-    }
-    await registerFromEnv(ops.assistants, graphPaths, { cwd: options.cwd });
-    registerRuntimeLogFormatter((info) => {
-        const config = getConfig();
-        if (config == null)
-            return info;
-        const node = config.metadata?.["langgraph_node"];
-        if (node != null)
-            info.langgraph_node = node;
-        return info;
-    });
-    const app = new Hono();
-    app.use(contextStorage());
-    app.use(async (c, next) => {
-        c.set("LANGGRAPH_OPS", ops);
-        await next();
-    });
-    // Loopback fetch used by webhooks and custom routes
-    bindLoopbackFetch(app);
-    app.post("/internal/truncate", zValidator("json", z.object({
-        runs: z.boolean().optional(),
-        threads: z.boolean().optional(),
-        assistants: z.boolean().optional(),
-        checkpointer: z.boolean().optional(),
-        store: z.boolean().optional(),
-    })), (c) => {
-        const { runs, threads, assistants, checkpointer, store } = c.req.valid("json");
-        ops.truncate({ runs, threads, assistants, checkpointer, store });
-        return c.json({ ok: true });
-    });
-    app.use(cors(options.http?.cors));
-    app.use(requestLogger());
-    if (options.auth?.path) {
-        logger.info(`Loading auth from ${options.auth.path}`);
-        await registerAuth(options.auth, { cwd: options.cwd });
-        app.use(auth());
-    }
-    if (options.http?.app) {
-        logger.info(`Loading HTTP app from ${options.http.app}`);
-        const { api } = await registerHttp(options.http.app, { cwd: options.cwd });
-        app.route("/", api);
-    }
-    app.use(ensureContentType());
-    if (!options.http?.disable_meta)
-        app.route("/", meta);
-    if (!options.http?.disable_assistants)
-        app.route("/", assistants);
-    if (!options.http?.disable_runs)
-        app.route("/", runs);
-    if (!options.http?.disable_threads)
-        app.route("/", threads);
-    if (!options.http?.disable_store)
-        app.route("/", store);
-    if (options.ui) {
-        logger.info(`Registering UI from ${options.cwd}`);
-        const { api, registerGraphUi } = await import("./ui/load.mjs");
-        await registerGraphUi(options.ui, {
-            cwd: options.cwd,
-            config: options.ui_config,
-        });
-        app.route("/", api);
-    }
-    logger.info(`Starting ${options.nWorkers} workers`);
-    for (let i = 0; i < options.nWorkers; i++)
-        queue(ops);
-    return new Promise((resolve) => {
-        serve({ fetch: app.fetch, port: options.port, hostname: options.host }, (c) => {
-            resolve({ host: `${c.address}:${c.port}`, cleanup });
-        });
-    });
-}

package/dist/state.d.mts

@@ -1,3 +0,0 @@
-import type { StateSnapshot } from "@langchain/langgraph";
-import type { ThreadState } from "./storage/types.mjs";
-export declare const stateSnapshotToThreadState: (state: StateSnapshot) => ThreadState;

package/dist/state.mjs

@@ -1,30 +0,0 @@
-import { runnableConfigToCheckpoint } from "./utils/runnableConfig.mjs";
-import { serializeError } from "./utils/serde.mjs";
-const isStateSnapshot = (state) => {
-    return "values" in state && "next" in state;
-};
-export const stateSnapshotToThreadState = (state) => {
-    return {
-        values: state.values,
-        next: state.next,
-        tasks: state.tasks.map((task) => ({
-            id: task.id,
-            name: task.name,
-            error: task.error != null ? serializeError(task.error).message : null,
-            interrupts: task.interrupts,
-            path: task.path,
-            // TODO: too many type assertions, check if this is actually correct
-            checkpoint: task.state != null && "configurable" in task.state
-                ? task.state.configurable ?? null
-                : null,
-            state: task.state != null && isStateSnapshot(task.state)
-                ? stateSnapshotToThreadState(task.state)
-                : null,
-            result: task.result ?? null,
-        })),
-        metadata: state.metadata,
-        created_at: state.createdAt ? new Date(state.createdAt) : null,
-        checkpoint: runnableConfigToCheckpoint(state.config),
-        parent_checkpoint: runnableConfigToCheckpoint(state.parentConfig),
-    };
-};

package/dist/storage/checkpoint.d.mts

@@ -1,19 +0,0 @@
-import type { RunnableConfig } from "@langchain/core/runnables";
-import { type Checkpoint, type CheckpointMetadata, MemorySaver } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./persist.mjs";
-declare class InMemorySaver extends MemorySaver {
-    initialize(cwd: string): Promise<FileSystemPersistence<{
-        storage: typeof MemorySaver.prototype.storage;
-        writes: typeof MemorySaver.prototype.writes;
-    }>>;
-    clear(): void;
-    getTuple(...args: Parameters<MemorySaver["getTuple"]>): ReturnType<MemorySaver["getTuple"]>;
-    list(...args: Parameters<MemorySaver["list"]>): ReturnType<MemorySaver["list"]>;
-    putWrites(...args: Parameters<MemorySaver["putWrites"]>): Promise<void>;
-    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
-    delete(threadId: string, runId: string | null | undefined): Promise<void>;
-    copy(threadId: string, newThreadId: string): Promise<void>;
-    toJSON(): string;
-}
-export declare const checkpointer: InMemorySaver;
-export {};

package/dist/storage/checkpoint.mjs

@@ -1,127 +0,0 @@
-import { MemorySaver, } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./persist.mjs";
-const EXCLUDED_KEYS = ["checkpoint_ns", "checkpoint_id", "run_id", "thread_id"];
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-const WriteKey = {
-    serialize: (key) => {
-        return JSON.stringify(key);
-    },
-    deserialize: (key) => {
-        const [threadId, checkpointNamespace, checkpointId] = JSON.parse(key);
-        return [threadId, checkpointNamespace, checkpointId];
-    },
-};
-const conn = new FileSystemPersistence(".langgraphjs_api.checkpointer.json", () => ({
-    storage: {},
-    writes: {},
-}));
-class InMemorySaver extends MemorySaver {
-    async initialize(cwd) {
-        await conn.initialize(cwd);
-        await conn.with(({ storage, writes }) => {
-            this.storage = storage;
-            this.writes = writes;
-        });
-        return conn;
-    }
-    clear() {
-        // { [threadId: string]: { [checkpointNs: string]: { [checkpointId]: [checkpoint, metadata, parentId] } }}
-        this.storage = {};
-        // { [WriteKey]: CheckpointPendingWrite[] }
-        this.writes = {};
-    }
-    // Patch every method that has access to this.storage or this.writes
-    // to also persist the changes to the filesystem in a non-blocking manner
-    async getTuple(...args) {
-        return await conn.with(() => super.getTuple(...args));
-    }
-    async *list(...args) {
-        yield* conn.withGenerator(super.list(...args));
-    }
-    async putWrites(...args) {
-        return await conn.with(() => super.putWrites(...args));
-    }
-    async put(config, checkpoint, metadata) {
-        return await conn.with(() => super.put(config, checkpoint, {
-            ...Object.fromEntries(Object.entries(config.configurable ?? {}).filter(([key]) => !key.startsWith("__") && !EXCLUDED_KEYS.includes(key))),
-            ...config.metadata,
-            ...metadata,
-        }));
-    }
-    async delete(threadId, runId) {
-        if (this.storage[threadId] == null)
-            return;
-        return await conn.with(() => {
-            if (runId != null) {
-                const writeKeysToDelete = [];
-                for (const ns of Object.keys(this.storage[threadId])) {
-                    for (const id of Object.keys(this.storage[threadId][ns])) {
-                        const [_checkpoint, metadata, _parentId] = this.storage[threadId][ns][id];
-                        const jsonMetadata = JSON.parse(textDecoder.decode(metadata));
-                        if (jsonMetadata.run_id === runId) {
-                            delete this.storage[threadId][ns][id];
-                            writeKeysToDelete.push(WriteKey.serialize([threadId, ns, id]));
-                            if (Object.keys(this.storage[threadId][ns]).length === 0) {
-                                delete this.storage[threadId][ns];
-                            }
-                        }
-                    }
-                }
-                for (const key of writeKeysToDelete) {
-                    delete this.writes[key];
-                }
-            }
-            else {
-                delete this.storage[threadId];
-                // delete all writes for this thread
-                const writeKeys = Object.keys(this.writes);
-                for (const key of writeKeys) {
-                    const [writeThreadId] = WriteKey.deserialize(key);
-                    if (writeThreadId === threadId)
-                        delete this.writes[key];
-                }
-            }
-        });
-    }
-    async copy(threadId, newThreadId) {
-        return await conn.with(() => {
-            // copy storage over
-            const newThreadCheckpoints = {};
-            for (const oldNs of Object.keys(this.storage[threadId] ?? {})) {
-                const newNs = oldNs.replace(threadId, newThreadId);
-                for (const oldId of Object.keys(this.storage[threadId][oldNs])) {
-                    const newId = oldId.replace(threadId, newThreadId);
-                    const [checkpoint, metadata, oldParentId] = this.storage[threadId][oldNs][oldId];
-                    const newParentId = oldParentId?.replace(threadId, newThreadId);
-                    const rawMetadata = textDecoder
-                        .decode(metadata)
-                        .replaceAll(threadId, newThreadId);
-                    newThreadCheckpoints[newNs] ??= {};
-                    newThreadCheckpoints[newNs][newId] = [
-                        checkpoint,
-                        textEncoder.encode(rawMetadata),
-                        newParentId,
-                    ];
-                }
-            }
-            this.storage[newThreadId] = newThreadCheckpoints;
-            // copy writes over (if any)
-            const outerKeys = [];
-            for (const keyJson of Object.keys(this.writes)) {
-                const key = WriteKey.deserialize(keyJson);
-                if (key[0] === threadId)
-                    outerKeys.push(keyJson);
-            }
-            for (const keyJson of outerKeys) {
-                const [_threadId, checkpointNamespace, checkpointId] = WriteKey.deserialize(keyJson);
-                this.writes[WriteKey.serialize([newThreadId, checkpointNamespace, checkpointId])] = structuredClone(this.writes[keyJson]);
-            }
-        });
-    }
-    toJSON() {
-        // Prevent serialization of internal state
-        return "[InMemorySaver]";
-    }
-}
-export const checkpointer = new InMemorySaver();

package/dist/storage/context.d.mts

@@ -1,3 +0,0 @@
-export declare const assistants: () => import("./types.mjs").AssistantsRepo;
-export declare const runs: () => import("./types.mjs").RunsRepo;
-export declare const threads: () => import("./types.mjs").ThreadsRepo;

package/dist/storage/context.mjs

@@ -1,11 +0,0 @@
-// Hono context helpers for accessing repositories, etc.
-import { getContext } from "hono/context-storage";
-export const assistants = () => {
-    return getContext().var.LANGGRAPH_OPS.assistants;
-};
-export const runs = () => {
-    return getContext().var.LANGGRAPH_OPS.runs;
-};
-export const threads = () => {
-    return getContext().var.LANGGRAPH_OPS.threads;
-};

package/dist/storage/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/storage/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,
-};