@langchain/langgraph-api 1.1.1 → 1.1.8

package/dist/api/runs.mjs

@@ -1,324 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { HTTPException } from "hono/http-exception";
-import { streamSSE } from "hono/streaming";
-import { v4 as uuid4 } from "uuid";
-import { z } from "zod/v3";
-import { getAssistantId } from "../graph/load.mjs";
-import { logError, logger } from "../logging.mjs";
-import * as schemas from "../schemas.mjs";
-import { runs, threads } from "../storage/context.mjs";
-import { getDisconnectAbortSignal, jsonExtra, waitKeepAlive, } from "../utils/hono.mjs";
-import { serialiseAsDict } from "../utils/serde.mjs";
-const api = new Hono();
-const createValidRun = async (threadId, payload, kwargs) => {
-    const { assistant_id: assistantId, ...run } = payload;
-    const { auth, headers } = kwargs ?? {};
-    const runId = uuid4();
-    const streamMode = Array.isArray(payload.stream_mode)
-        ? payload.stream_mode
-        : payload.stream_mode != null
-            ? [payload.stream_mode]
-            : [];
-    if (streamMode.length === 0)
-        streamMode.push("values");
-    const multitaskStrategy = payload.multitask_strategy ?? "reject";
-    const preventInsertInInflight = multitaskStrategy === "reject";
-    const config = { ...run.config };
-    if (run.checkpoint_id) {
-        config.configurable ??= {};
-        config.configurable.checkpoint_id = run.checkpoint_id;
-    }
-    if (run.checkpoint) {
-        config.configurable ??= {};
-        Object.assign(config.configurable, run.checkpoint);
-    }
-    if (run.langsmith_tracer) {
-        config.configurable ??= {};
-        Object.assign(config.configurable, {
-            langsmith_project: run.langsmith_tracer.project_name,
-            langsmith_example_id: run.langsmith_tracer.example_id,
-        });
-    }
-    if (headers) {
-        for (const [rawKey, value] of headers.entries()) {
-            const key = rawKey.toLowerCase();
-            if (key.startsWith("x-")) {
-                if (["x-api-key", "x-tenant-id", "x-service-key"].includes(key)) {
-                    continue;
-                }
-                config.configurable ??= {};
-                config.configurable[key] = value;
-            }
-            else if (key === "user-agent") {
-                config.configurable ??= {};
-                config.configurable[key] = value;
-            }
-        }
-    }
-    let userId;
-    if (auth) {
-        userId = auth.user.identity ?? auth.user.id;
-        config.configurable ??= {};
-        config.configurable["langgraph_auth_user"] = auth.user;
-        config.configurable["langgraph_auth_user_id"] = userId;
-        config.configurable["langgraph_auth_permissions"] = auth.scopes;
-    }
-    let feedbackKeys = run.feedback_keys != null
-        ? Array.isArray(run.feedback_keys)
-            ? run.feedback_keys
-            : [run.feedback_keys]
-        : undefined;
-    if (!feedbackKeys?.length)
-        feedbackKeys = undefined;
-    const [first, ...inflight] = await runs().put(runId, getAssistantId(assistantId), {
-        input: run.input,
-        command: run.command,
-        config,
-        context: run.context,
-        stream_mode: streamMode,
-        interrupt_before: run.interrupt_before,
-        interrupt_after: run.interrupt_after,
-        webhook: run.webhook,
-        feedback_keys: feedbackKeys,
-        temporary: threadId == null && (run.on_completion ?? "delete") === "delete",
-        subgraphs: run.stream_subgraphs ?? false,
-        resumable: run.stream_resumable ?? false,
-    }, {
-        threadId,
-        userId,
-        metadata: run.metadata,
-        status: "pending",
-        multitaskStrategy,
-        preventInsertInInflight,
-        afterSeconds: payload.after_seconds,
-        ifNotExists: payload.if_not_exists,
-    }, auth);
-    if (first?.run_id === runId) {
-        logger.info("Created run", { run_id: runId, thread_id: threadId });
-        if ((multitaskStrategy === "interrupt" || multitaskStrategy === "rollback") &&
-            inflight.length > 0) {
-            try {
-                await runs().cancel(threadId, inflight.map((run) => run.run_id), { action: multitaskStrategy }, auth);
-            }
-            catch (error) {
-                logger.warn("Failed to cancel inflight runs, might be already cancelled", {
-                    error,
-                    run_ids: inflight.map((run) => run.run_id),
-                    thread_id: threadId,
-                });
-            }
-        }
-        return first;
-    }
-    else if (multitaskStrategy === "reject") {
-        throw new HTTPException(422, {
-            message: "Thread is already running a task. Wait for it to finish or choose a different multitask strategy.",
-        });
-    }
-    throw new HTTPException(500, {
-        message: "Unreachable state when creating run",
-    });
-};
-api.post("/runs/crons", zValidator("json", schemas.CronCreate), async () => {
-    // Create Thread Cron
-    throw new HTTPException(500, { message: "Not implemented" });
-});
-api.post("/runs/crons/search", zValidator("json", schemas.CronSearch), async () => {
-    // Search Crons
-    throw new HTTPException(500, { message: "Not implemented" });
-});
-api.delete("/runs/crons/:cron_id", zValidator("param", z.object({ cron_id: z.string().uuid() })), async () => {
-    // Delete Cron
-    throw new HTTPException(500, { message: "Not implemented" });
-});
-api.post("/threads/:thread_id/runs/crons", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.CronCreate), async () => {
-    // Create Thread Cron
-    throw new HTTPException(500, { message: "Not implemented" });
-});
-api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
-    // Stream Stateless Run
-    const payload = c.req.valid("json");
-    const run = await createValidRun(undefined, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/runs/${run.run_id}`);
-    return streamSSE(c, async (stream) => {
-        const cancelOnDisconnect = payload.on_disconnect === "cancel"
-            ? getDisconnectAbortSignal(c, stream)
-            : undefined;
-        try {
-            for await (const { event, data } of runs().stream.join(run.run_id, undefined, {
-                cancelOnDisconnect,
-                lastEventId: run.kwargs.resumable ? "-1" : undefined,
-                ignore404: true,
-            }, c.var.auth)) {
-                await stream.writeSSE({ data: serialiseAsDict(data), event });
-            }
-        }
-        catch (error) {
-            logError(error, { prefix: "Error streaming run" });
-        }
-    });
-});
-// TODO: port to Python API
-api.get("/runs/:run_id/stream", zValidator("param", z.object({ run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
-    const { run_id } = c.req.valid("param");
-    const query = c.req.valid("query");
-    const lastEventId = c.req.header("Last-Event-ID") || undefined;
-    c.header("Content-Location", `/runs/${run_id}`);
-    return streamSSE(c, async (stream) => {
-        const cancelOnDisconnect = query.cancel_on_disconnect
-            ? getDisconnectAbortSignal(c, stream)
-            : undefined;
-        try {
-            for await (const { id, event, data } of runs().stream.join(run_id, undefined, { cancelOnDisconnect, lastEventId, ignore404: true }, c.var.auth)) {
-                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
-            }
-        }
-        catch (error) {
-            logError(error, { prefix: "Error streaming run" });
-        }
-    });
-});
-api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
-    // Wait Stateless Run
-    const payload = c.req.valid("json");
-    const run = await createValidRun(undefined, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/runs/${run.run_id}`);
-    return waitKeepAlive(c, runs().wait(run.run_id, undefined, c.var.auth));
-});
-api.post("/runs", zValidator("json", schemas.RunCreate), async (c) => {
-    // Create Stateless Run
-    const payload = c.req.valid("json");
-    const run = await createValidRun(undefined, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/runs/${run.run_id}`);
-    return jsonExtra(c, run);
-});
-api.post("/runs/batch", zValidator("json", schemas.RunBatchCreate), async (c) => {
-    // Batch Runs
-    const payload = c.req.valid("json");
-    const runs = await Promise.all(payload.map((run) => createValidRun(undefined, run, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    })));
-    return jsonExtra(c, runs);
-});
-api.get("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
-    limit: z.coerce.number().nullish(),
-    offset: z.coerce.number().nullish(),
-    status: z.string().nullish(),
-    metadata: z.record(z.string(), z.unknown()).nullish(),
-})), async (c) => {
-    // List runs
-    const { thread_id } = c.req.valid("param");
-    const { limit, offset, status, metadata } = c.req.valid("query");
-    const [runsResponse] = await Promise.all([
-        runs().search(thread_id, { limit, offset, status, metadata }, c.var.auth),
-        threads().get(thread_id, c.var.auth),
-    ]);
-    return jsonExtra(c, runsResponse);
-});
-api.post("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
-    // Create Run
-    const { thread_id } = c.req.valid("param");
-    const payload = c.req.valid("json");
-    const run = await createValidRun(thread_id, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
-    return jsonExtra(c, run);
-});
-api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
-    // Stream Run
-    const { thread_id } = c.req.valid("param");
-    const payload = c.req.valid("json");
-    const run = await createValidRun(thread_id, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
-    return streamSSE(c, async (stream) => {
-        const cancelOnDisconnect = payload.on_disconnect === "cancel"
-            ? getDisconnectAbortSignal(c, stream)
-            : undefined;
-        try {
-            for await (const { id, event, data } of runs().stream.join(run.run_id, thread_id, {
-                cancelOnDisconnect,
-                lastEventId: run.kwargs.resumable ? "-1" : undefined,
-            }, c.var.auth)) {
-                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
-            }
-        }
-        catch (error) {
-            logError(error, { prefix: "Error streaming run" });
-        }
-    });
-});
-api.post("/threads/:thread_id/runs/wait", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
-    // Wait Run
-    const { thread_id } = c.req.valid("param");
-    const payload = c.req.valid("json");
-    const run = await createValidRun(thread_id, payload, {
-        auth: c.var.auth,
-        headers: c.req.raw.headers,
-    });
-    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
-    return waitKeepAlive(c, runs().join(run.run_id, thread_id, c.var.auth));
-});
-api.get("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
-    const { thread_id, run_id } = c.req.valid("param");
-    const [run] = await Promise.all([
-        runs().get(run_id, thread_id, c.var.auth),
-        threads().get(thread_id, c.var.auth),
-    ]);
-    if (run == null)
-        throw new HTTPException(404, { message: "Run not found" });
-    return jsonExtra(c, run);
-});
-api.delete("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
-    // Delete Run
-    const { thread_id, run_id } = c.req.valid("param");
-    await runs().delete(run_id, thread_id, c.var.auth);
-    return c.body(null, 204);
-});
-api.get("/threads/:thread_id/runs/:run_id/join", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
-    // Join Run Http
-    const { thread_id, run_id } = c.req.valid("param");
-    return jsonExtra(c, await runs().join(run_id, thread_id, c.var.auth));
-});
-api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
-    // Stream Run Http
-    const { thread_id, run_id } = c.req.valid("param");
-    const { cancel_on_disconnect } = c.req.valid("query");
-    const lastEventId = c.req.header("Last-Event-ID") || undefined;
-    return streamSSE(c, async (stream) => {
-        const signal = cancel_on_disconnect
-            ? getDisconnectAbortSignal(c, stream)
-            : undefined;
-        for await (const { id, event, data } of runs().stream.join(run_id, thread_id, { cancelOnDisconnect: signal, lastEventId }, c.var.auth)) {
-            await stream.writeSSE({ id, data: serialiseAsDict(data), event });
-        }
-    });
-});
-api.post("/threads/:thread_id/runs/:run_id/cancel", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({
-    wait: z.coerce.boolean().optional().default(false),
-    action: z.enum(["interrupt", "rollback"]).optional().default("interrupt"),
-})), async (c) => {
-    // Cancel Run Http
-    const { thread_id, run_id } = c.req.valid("param");
-    const { wait, action } = c.req.valid("query");
-    await runs().cancel(thread_id, [run_id], { action }, c.var.auth);
-    if (wait)
-        await runs().join(run_id, thread_id, c.var.auth);
-    return c.body(null, wait ? 204 : 202);
-});
-export default api;

package/dist/api/store.d.mts

@@ -1,3 +0,0 @@
-import { Hono } from "hono";
-declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-export default api;

package/dist/api/store.mjs

@@ -1,111 +0,0 @@
-import { Hono } from "hono";
-import { zValidator } from "@hono/zod-validator";
-import * as schemas from "../schemas.mjs";
-import { HTTPException } from "hono/http-exception";
-import { store as storageStore } from "../storage/store.mjs";
-import { handleAuthEvent } from "../auth/index.mjs";
-const api = new Hono();
-const validateNamespace = (namespace) => {
-    if (!namespace || namespace.length === 0) {
-        throw new HTTPException(400, { message: "Namespace is required" });
-    }
-    for (const label of namespace) {
-        if (!label || label.includes(".")) {
-            throw new HTTPException(422, {
-                message: "Namespace labels cannot be empty or contain periods. Received: " +
-                    namespace.join("."),
-            });
-        }
-    }
-};
-const mapItemsToApi = (item) => {
-    if (item == null)
-        return null;
-    const clonedItem = { ...item };
-    delete clonedItem.createdAt;
-    delete clonedItem.updatedAt;
-    clonedItem.created_at = item.createdAt;
-    clonedItem.updated_at = item.updatedAt;
-    return clonedItem;
-};
-api.post("/store/namespaces", zValidator("json", schemas.StoreListNamespaces), async (c) => {
-    // List Namespaces
-    const payload = c.req.valid("json");
-    if (payload.prefix)
-        validateNamespace(payload.prefix);
-    if (payload.suffix)
-        validateNamespace(payload.suffix);
-    await handleAuthEvent(c.var.auth, "store:list_namespaces", {
-        namespace: payload.prefix,
-        suffix: payload.suffix,
-        max_depth: payload.max_depth,
-        limit: payload.limit,
-        offset: payload.offset,
-    });
-    return c.json({
-        namespaces: await storageStore.listNamespaces({
-            limit: payload.limit ?? 100,
-            offset: payload.offset ?? 0,
-            prefix: payload.prefix,
-            suffix: payload.suffix,
-            maxDepth: payload.max_depth,
-        }),
-    });
-});
-api.post("/store/items/search", zValidator("json", schemas.StoreSearchItems), async (c) => {
-    // Search Items
-    const payload = c.req.valid("json");
-    if (payload.namespace_prefix)
-        validateNamespace(payload.namespace_prefix);
-    await handleAuthEvent(c.var.auth, "store:search", {
-        namespace: payload.namespace_prefix,
-        filter: payload.filter,
-        limit: payload.limit,
-        offset: payload.offset,
-        query: payload.query,
-    });
-    const items = await storageStore.search(payload.namespace_prefix, {
-        filter: payload.filter,
-        limit: payload.limit ?? 10,
-        offset: payload.offset ?? 0,
-        query: payload.query,
-    });
-    return c.json({ items: items.map(mapItemsToApi) });
-});
-api.put("/store/items", zValidator("json", schemas.StorePutItem), async (c) => {
-    // Put Item
-    const payload = c.req.valid("json");
-    if (payload.namespace)
-        validateNamespace(payload.namespace);
-    await handleAuthEvent(c.var.auth, "store:put", {
-        namespace: payload.namespace,
-        key: payload.key,
-        value: payload.value,
-    });
-    await storageStore.put(payload.namespace, payload.key, payload.value);
-    return c.body(null, 204);
-});
-api.delete("/store/items", zValidator("json", schemas.StoreDeleteItem), async (c) => {
-    // Delete Item
-    const payload = c.req.valid("json");
-    if (payload.namespace)
-        validateNamespace(payload.namespace);
-    await handleAuthEvent(c.var.auth, "store:delete", {
-        namespace: payload.namespace,
-        key: payload.key,
-    });
-    await storageStore.delete(payload.namespace ?? [], payload.key);
-    return c.body(null, 204);
-});
-api.get("/store/items", zValidator("query", schemas.StoreGetItem), async (c) => {
-    // Get Item
-    const payload = c.req.valid("query");
-    await handleAuthEvent(c.var.auth, "store:get", {
-        namespace: payload.namespace,
-        key: payload.key,
-    });
-    const key = payload.key;
-    const namespace = payload.namespace;
-    return c.json(mapItemsToApi(await storageStore.get(namespace, key)));
-});
-export default api;

package/dist/api/threads.d.mts

@@ -1,3 +0,0 @@
-import { Hono } from "hono";
-declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-export default api;

package/dist/api/threads.mjs

@@ -1,143 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { v4 as uuid4 } 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 || uuid4(), { 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/auth/custom.d.mts

@@ -1,9 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-import { type AuthContext } from "./index.mjs";
-declare module "hono" {
-    interface ContextVariableMap {
-        auth?: AuthContext | undefined;
-    }
-}
-export declare const auth: () => MiddlewareHandler;
-export { registerAuth } from "./index.mjs";

package/dist/auth/custom.mjs

@@ -1,32 +0,0 @@
-import { authenticate, isAuthRegistered, isStudioAuthDisabled, } from "./index.mjs";
-const STUDIO_USER = {
-    kind: "StudioUser",
-    display_name: "langgraph-studio-user",
-    identity: "langgraph-studio-user",
-    permissions: [],
-    is_authenticated: true,
-};
-export const auth = () => {
-    return async (c, next) => {
-        if (!isAuthRegistered())
-            return next();
-        // skip for /info
-        if (c.req.path === "/info")
-            return next();
-        // skip for UI asset requests
-        if (c.req.path.startsWith("/ui") && c.req.method === "GET")
-            return next();
-        if (!isStudioAuthDisabled() &&
-            c.req.header("x-auth-scheme") === "langsmith") {
-            c.set("auth", {
-                user: STUDIO_USER,
-                scopes: STUDIO_USER.permissions.slice(),
-            });
-            return next();
-        }
-        const auth = await authenticate(c.req.raw);
-        c.set("auth", auth);
-        return next();
-    };
-};
-export { registerAuth } from "./index.mjs";

package/dist/auth/index.d.mts

@@ -1,43 +0,0 @@
-import type { AuthEventValueMap } from "@langchain/langgraph-sdk/auth";
-export declare const isAuthRegistered: () => boolean;
-export declare const isStudioAuthDisabled: () => boolean;
-export type AuthFilters = Record<string, string | {
-    $eq?: string;
-    $contains?: string | string[];
-}> | undefined;
-export interface AuthContext {
-    user: {
-        identity: string;
-        permissions: string[];
-        display_name: string;
-        is_authenticated: boolean;
-        [key: string]: unknown;
-    };
-    scopes: string[];
-}
-export declare function authorize(payload: {
-    resource: string;
-    action: string;
-    value: unknown;
-    context: AuthContext | undefined | null;
-}): Promise<{
-    filters: AuthFilters;
-    value: unknown;
-}>;
-export declare function authenticate(request: Request): Promise<{
-    scopes: string[];
-    user: {
-        permissions: string[];
-        is_authenticated: boolean;
-        display_name: string;
-        identity: string;
-    };
-} | undefined>;
-export declare function registerAuth(auth: {
-    path?: string;
-    disable_studio_auth?: boolean;
-}, options: {
-    cwd: string;
-}): Promise<void>;
-export declare const handleAuthEvent: <T extends keyof AuthEventValueMap>(context: AuthContext | undefined, event: T, value: AuthEventValueMap[T]) => Promise<[AuthFilters | undefined, value: AuthEventValueMap[T]]>;
-export declare function isAuthMatching(metadata: Record<string, unknown> | undefined, filters: AuthFilters): boolean;