@langchain/langgraph-api 1.2.2 → 1.2.4

package/dist/src/api/threads.mjs

@@ -1,143 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { v7 as uuid7 } from "uuid";
-import { z } from "zod/v3";
-import * as schemas from "../schemas.mjs";
-import { stateSnapshotToThreadState } from "../state.mjs";
-import { threads } from "../storage/context.mjs";
-import { jsonExtra } from "../utils/hono.mjs";
-const api = new Hono();
-// Threads Routes
-api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
-    // Create Thread
-    const payload = c.req.valid("json");
-    const thread = await threads().put(payload.thread_id || uuid7(), { metadata: payload.metadata, if_exists: payload.if_exists ?? "raise" }, c.var.auth);
-    if (payload.supersteps?.length) {
-        await threads().state.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps, c.var.auth);
-    }
-    return jsonExtra(c, thread);
-});
-api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
-    // Search Threads
-    const payload = c.req.valid("json");
-    const result = [];
-    let total = 0;
-    for await (const item of threads().search({
-        status: payload.status,
-        values: payload.values,
-        metadata: payload.metadata,
-        ids: payload.ids,
-        limit: payload.limit ?? 10,
-        offset: payload.offset ?? 0,
-        sort_by: payload.sort_by ?? "created_at",
-        sort_order: payload.sort_order ?? "desc",
-        select: payload.select,
-    }, c.var.auth)) {
-        result.push(Object.fromEntries(Object.entries(item.thread).filter(([k]) => !payload.select || payload.select.includes(k))));
-        // Only set total if it's the first item
-        if (total === 0) {
-            total = item.total;
-        }
-    }
-    const nextOffset = (payload.offset ?? 0) + total;
-    if (total === payload.limit) {
-        c.res.headers.set("X-Pagination-Next", nextOffset.toString());
-        c.res.headers.set("X-Pagination-Total", (nextOffset + 1).toString());
-    }
-    else {
-        c.res.headers.set("X-Pagination-Total", nextOffset.toString());
-    }
-    return jsonExtra(c, result);
-});
-api.post("/threads/count", zValidator("json", schemas.ThreadCountRequest), async (c) => {
-    const payload = c.req.valid("json");
-    const total = await threads().count(payload, c.var.auth);
-    return c.json(total);
-});
-api.get("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
-    // Get Latest Thread State
-    const { thread_id } = c.req.valid("param");
-    const { subgraphs } = c.req.valid("query");
-    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id } }, { subgraphs }, c.var.auth));
-    return jsonExtra(c, state);
-});
-api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadStateUpdate), async (c) => {
-    // Update Thread State
-    const { thread_id } = c.req.valid("param");
-    const payload = c.req.valid("json");
-    const config = { configurable: { thread_id } };
-    if (payload.checkpoint_id) {
-        config.configurable ??= {};
-        config.configurable.checkpoint_id = payload.checkpoint_id;
-    }
-    if (payload.checkpoint) {
-        config.configurable ??= {};
-        Object.assign(config.configurable, payload.checkpoint);
-    }
-    const inserted = await threads().state.post(config, payload.values, payload.as_node, c.var.auth);
-    return jsonExtra(c, inserted);
-});
-api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object({
-    thread_id: z.string().uuid(),
-    checkpoint_id: z.string().uuid(),
-})), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
-    // Get Thread State At Checkpoint
-    const { thread_id, checkpoint_id } = c.req.valid("param");
-    const { subgraphs } = c.req.valid("query");
-    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id, checkpoint_id } }, { subgraphs }, c.var.auth));
-    return jsonExtra(c, state);
-});
-api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
-    subgraphs: schemas.coercedBoolean.optional(),
-    checkpoint: schemas.CheckpointSchema.nullish(),
-})), async (c) => {
-    // Get Thread State At Checkpoint Post
-    const { thread_id } = c.req.valid("param");
-    const { checkpoint, subgraphs } = c.req.valid("json");
-    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id, ...checkpoint } }, { subgraphs }, c.var.auth));
-    return jsonExtra(c, state);
-});
-api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
-    limit: z
-        .string()
-        .optional()
-        .default("10")
-        .transform((value) => parseInt(value, 10)),
-    before: z.string().optional(),
-})), async (c) => {
-    // Get Thread History
-    const { thread_id } = c.req.valid("param");
-    const { limit, before } = c.req.valid("query");
-    const states = await threads().state.list({ configurable: { thread_id, checkpoint_ns: "" } }, { limit, before }, c.var.auth);
-    return jsonExtra(c, states.map(stateSnapshotToThreadState));
-});
-api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), async (c) => {
-    // Get Thread History Post
-    const { thread_id } = c.req.valid("param");
-    const { limit, before, metadata, checkpoint } = c.req.valid("json");
-    const states = await threads().state.list({ configurable: { thread_id, checkpoint_ns: "", ...checkpoint } }, { limit, before, metadata }, c.var.auth);
-    return jsonExtra(c, states.map(stateSnapshotToThreadState));
-});
-api.get("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
-    // Get Thread
-    const { thread_id } = c.req.valid("param");
-    return jsonExtra(c, await threads().get(thread_id, c.var.auth));
-});
-api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
-    // Delete Thread
-    const { thread_id } = c.req.valid("param");
-    await threads().delete(thread_id, c.var.auth);
-    return new Response(null, { status: 204 });
-});
-api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadPatchRequest), async (c) => {
-    // Patch Thread
-    const { thread_id } = c.req.valid("param");
-    const { metadata } = c.req.valid("json");
-    return jsonExtra(c, await threads().patch(thread_id, { metadata }, c.var.auth));
-});
-api.post("/threads/:thread_id/copy", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
-    // Copy Thread
-    const { thread_id } = c.req.valid("param");
-    return jsonExtra(c, await threads().copy(thread_id, c.var.auth));
-});
-export default api;

package/dist/src/graph/load.utils.d.mts

@@ -1,22 +0,0 @@
-import type { CompiledGraph } from "@langchain/langgraph";
-export declare const GRAPHS: Record<string, CompiledGraph<string>>;
-export declare const NAMESPACE_GRAPH: Uint8Array<ArrayBufferLike>;
-export type CompiledGraphFactory<T extends string> = (config: {
-    configurable?: Record<string, unknown>;
-}) => Promise<CompiledGraph<T>>;
-export declare function resolveGraph(spec: string, options: {
-    cwd: string;
-    onlyFilePresence?: false;
-}): Promise<{
-    sourceFile: string;
-    exportSymbol: string;
-    resolved: CompiledGraph<string> | CompiledGraphFactory<string>;
-}>;
-export declare function resolveGraph(spec: string, options: {
-    cwd: string;
-    onlyFilePresence: true;
-}): Promise<{
-    sourceFile: string;
-    exportSymbol: string;
-    resolved: undefined;
-}>;

package/dist/src/graph/load.utils.mjs

@@ -1,59 +0,0 @@
-import * as uuid from "uuid";
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-export const GRAPHS = {};
-export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
-export async function resolveGraph(spec, options) {
-    const [userFile, exportSymbol] = spec.split(":", 2);
-    const sourceFile = path.resolve(options.cwd, userFile);
-    // validate file exists
-    await fs.stat(sourceFile);
-    if (options?.onlyFilePresence) {
-        return { sourceFile, exportSymbol, resolved: undefined };
-    }
-    const isGraph = (graph) => {
-        if (typeof graph !== "object" || graph == null)
-            return false;
-        return "compile" in graph && typeof graph.compile === "function";
-    };
-    const isCompiledGraph = (graph) => {
-        if (typeof graph !== "object" || graph == null)
-            return false;
-        return ("builder" in graph &&
-            typeof graph.builder === "object" &&
-            graph.builder != null);
-    };
-    const graph = await import(pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]);
-    // obtain the graph, and if not compiled, compile it
-    const resolved = await (async () => {
-        if (!graph)
-            throw new Error("Failed to load graph: graph is nullush");
-        const afterResolve = (graphLike) => {
-            const graph = isGraph(graphLike) ? graphLike.compile() : graphLike;
-            // TODO: hack, remove once LangChain 1.x createAgent is fixed.
-            // `createAgent` returns a ReactAgent wrapper that itself looks
-            // like a CompiledGraph (it has a `builder` — the outer
-            // StateGraph) *and* exposes the real compiled pregel under
-            // `.graph`. Unwrap to the inner graph whenever both are
-            // present so downstream code (e.g. the v2 streaming path that
-            // keys off `graph.streamTransformers`) sees the actual pregel
-            // rather than the wrapper.
-            const inner = graph.graph;
-            if (inner != null &&
-                typeof inner === "object" &&
-                isCompiledGraph(inner)) {
-                return inner;
-            }
-            return graph;
-        };
-        if (typeof graph === "function") {
-            return async (config) => {
-                const graphLike = await graph(config);
-                return afterResolve(graphLike);
-            };
-        }
-        return afterResolve(await graph);
-    })();
-    return { sourceFile, exportSymbol, resolved };
-}

package/dist/src/protocol/service.d.mts

@@ -1,101 +0,0 @@
-import type { RunsRepo, ThreadsRepo } from "../storage/types.mjs";
-import type { EventSinkEntry, EventSinkFilter, ProtocolCommand, ProtocolError, ProtocolEvent, ProtocolSuccess, ThreadRecord, ProtocolTransportName } from "./types.mjs";
-type ServiceBindings = {
-    runs: RunsRepo;
-    threads: ThreadsRepo;
-};
-/**
- * Transport-agnostic sink used to forward normalized protocol events into a
- * concrete delivery mechanism such as WebSocket or SSE.
- */
-type EventSink = (message: ProtocolEvent) => Promise<void> | void;
-/**
- * Thread-scoped connection registry and command dispatcher.
- *
- * In the thread-centric protocol, a `ThreadRecord` holds ephemeral
- * connection state for an active client interacting with a thread. The
- * thread itself is durable (lives in the checkpoint store); records are
- * created lazily on first interaction and dropped when all connections
- * close.
- */
-export declare class ProtocolService {
-    private readonly bindings;
-    private readonly threads;
-    constructor(bindings: ServiceBindings);
-    getThread(threadId: string): ThreadRecord | undefined;
-    /**
-     * Get or create the in-memory record for a thread. Records hold
-     * ephemeral connection state (event sinks, current run session) and
-     * are created on first use for any thread the client targets.
-     */
-    ensureThread(options: {
-        threadId: string;
-        transport: ProtocolTransportName;
-        auth?: ThreadRecord["auth"];
-        sendEvent?: EventSink;
-    }): ThreadRecord;
-    /**
-     * Attach a live transport consumer (WebSocket) and flush any buffered
-     * events.
-     */
-    attachEventSink(threadId: string, sendEvent: EventSink): Promise<ThreadRecord>;
-    /**
-     * Attach a filtered SSE event sink and replay buffered events that
-     * match the filter.
-     *
-     * The sink is flagged `pendingReplay` while draining so that the live
-     * `send` path skips it — preventing live events from interleaving with
-     * the replay loop's awaits and producing out-of-order delivery.
-     */
-    attachFilteredEventSink(threadId: string, sink: EventSinkEntry): Promise<ThreadRecord>;
-    /**
-     * Remove an SSE event sink when the connection closes.
-     */
-    detachEventSink(threadId: string, sinkId: string): void;
-    closeThread(threadId: string): Promise<void>;
-    /**
-     * Route a protocol command on a thread.
-     *
-     * `subscription.subscribe` can resolve to `null` on ordered
-     * transports (WebSocket) — see
-     * `ProtocolSession.handleSubscribeForResponse` for the rationale.
-     * Callers must treat `null` as "response already sent on the wire"
-     * and skip any additional send.
-     */
-    handleCommand(threadId: string, command: ProtocolCommand): Promise<ProtocolSuccess | ProtocolError | null>;
-    /**
-     * Start a new run, resume an interrupted run, or continue on the
-     * thread depending on its current state.
-     */
-    private handleRunStart;
-    private handleInputRespond;
-    private createOrResumeRun;
-    private hasPendingInterrupts;
-    private hasPendingInterruptsForThread;
-    private handleStateGet;
-    private forwardToRunSession;
-    /**
-     * Drain any WebSocket subscribes that arrived before the first run
-     * session was bound. Called from `createOrResumeRun` right after
-     * {@link ensureRunSession} sets up `record.session`.
-     *
-     * Each parked command is forwarded to the freshly-bound session,
-     * added to `activeSubscriptions` so it persists across subsequent
-     * runs, and its deferred `handleCommand` promise is resolved so the
-     * WebSocket handler can finally send the response.
-     */
-    private drainPendingSubscribes;
-    /**
-     * Bind the thread record to a concrete LangGraph run and forward
-     * normalized protocol events to attached sinks.
-     */
-    private ensureRunSession;
-    private requireThread;
-    error(id: number | null, code: ProtocolError["error"], message: string): ProtocolError;
-}
-/**
- * Check whether a protocol event matches an SSE event sink filter.
- * Mirrors the subscription matching logic in {@link RunProtocolSession}.
- */
-export declare function matchesSinkFilter(filter: EventSinkFilter, event: ProtocolEvent): boolean;
-export {};