@langchain/langgraph-api 1.1.8 → 1.1.10

package/README.md

@@ -4,6 +4,6 @@ In-memory implementation of the LangGraph.js API.
 
 ## Tests
 
-1. Build the latest code changes to test: `yarn build`
-1. Start a local server: `yarn dev`
-1. Run the tests: `yarn test`
+1. Build the latest code changes to test: `pnpm build`
+1. Start a local server: `pnpm dev`
+1. Run the tests: `pnpm test`

package/dist/api/assistants.d.mts

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

package/dist/api/assistants.mjs

@@ -0,0 +1,193 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { v4 as uuid } from "uuid";
+import { z } from "zod/v3";
+import { getAssistantId, getCachedStaticGraphSchema, getGraph, } from "../graph/load.mjs";
+import { getRuntimeGraphSchema } from "../graph/parser/index.mjs";
+import { HTTPException } from "hono/http-exception";
+import * as schemas from "../schemas.mjs";
+import { assistants } from "../storage/context.mjs";
+const api = new Hono();
+const RunnableConfigSchema = z.object({
+    tags: z.array(z.string()).optional(),
+    metadata: z.record(z.unknown()).optional(),
+    run_name: z.string().optional(),
+    max_concurrency: z.number().optional(),
+    recursion_limit: z.number().optional(),
+    configurable: z.record(z.unknown()).optional(),
+    run_id: z.string().uuid().optional(),
+});
+const getRunnableConfig = (userConfig) => {
+    if (!userConfig)
+        return {};
+    return {
+        configurable: userConfig.configurable,
+        tags: userConfig.tags,
+        metadata: userConfig.metadata,
+        runName: userConfig.run_name,
+        maxConcurrency: userConfig.max_concurrency,
+        recursionLimit: userConfig.recursion_limit,
+        runId: userConfig.run_id,
+    };
+};
+api.post("/assistants", zValidator("json", schemas.AssistantCreate), async (c) => {
+    // Create Assistant
+    const payload = c.req.valid("json");
+    const assistant = await assistants().put(payload.assistant_id ?? uuid(), {
+        config: payload.config ?? {},
+        context: payload.context ?? {},
+        graph_id: payload.graph_id,
+        metadata: payload.metadata ?? {},
+        if_exists: payload.if_exists ?? "raise",
+        name: payload.name ?? "Untitled",
+        description: payload.description,
+    }, c.var.auth);
+    return c.json(assistant);
+});
+api.post("/assistants/search", zValidator("json", schemas.AssistantSearchRequest), async (c) => {
+    // Search Assistants
+    const payload = c.req.valid("json");
+    const result = [];
+    let total = 0;
+    for await (const item of assistants().search({
+        graph_id: payload.graph_id,
+        name: payload.name,
+        metadata: payload.metadata,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+        sort_by: payload.sort_by,
+        sort_order: payload.sort_order,
+        select: payload.select,
+    }, c.var.auth)) {
+        result.push(Object.fromEntries(Object.entries(item.assistant).filter(([k]) => !payload.select || payload.select.includes(k))));
+        if (total === 0) {
+            total = item.total;
+        }
+    }
+    if (total === payload.limit) {
+        c.res.headers.set("X-Pagination-Next", ((payload.offset ?? 0) + total).toString());
+        c.res.headers.set("X-Pagination-Total", ((payload.offset ?? 0) + total + 1).toString());
+    }
+    else {
+        c.res.headers.set("X-Pagination-Total", ((payload.offset ?? 0) + total).toString());
+    }
+    return c.json(result);
+});
+api.post("/assistants/count", zValidator("json", schemas.AssistantCountRequest), async (c) => {
+    const payload = c.req.valid("json");
+    const total = await assistants().count(payload, c.var.auth);
+    return c.json(total);
+});
+api.get("/assistants/:assistant_id", async (c) => {
+    // Get Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await assistants().get(assistantId, c.var.auth));
+});
+api.delete("/assistants/:assistant_id", async (c) => {
+    // Delete Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await assistants().delete(assistantId, c.var.auth));
+});
+api.patch("/assistants/:assistant_id", zValidator("json", schemas.AssistantPatch), async (c) => {
+    // Patch Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const payload = c.req.valid("json");
+    return c.json(await assistants().patch(assistantId, payload, c.var.auth));
+});
+api.get("/assistants/:assistant_id/graph", zValidator("query", z.object({ xray: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Assistant Graph
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const assistant = await assistants().get(assistantId, c.var.auth);
+    const { xray } = c.req.valid("query");
+    const config = getRunnableConfig(assistant.config);
+    const graph = await getGraph(assistant.graph_id, config);
+    const drawable = await graph.getGraphAsync({
+        ...config,
+        xray: xray ?? undefined,
+    });
+    return c.json(drawable.toJSON());
+});
+api.get("/assistants/:assistant_id/schemas", zValidator("json", z.object({ config: RunnableConfigSchema.optional() })), async (c) => {
+    // Get Assistant Schemas
+    const json = c.req.valid("json");
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const assistant = await assistants().get(assistantId, c.var.auth);
+    const config = getRunnableConfig(json.config);
+    const graph = await getGraph(assistant.graph_id, config);
+    const schema = await (async () => {
+        const runtimeSchema = await getRuntimeGraphSchema(graph);
+        if (runtimeSchema)
+            return runtimeSchema;
+        const graphSchema = await getCachedStaticGraphSchema(assistant.graph_id);
+        const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+        if (!rootGraphId)
+            throw new HTTPException(404, { message: "Failed to find root graph" });
+        return graphSchema[rootGraphId];
+    })();
+    return c.json({
+        graph_id: assistant.graph_id,
+        input_schema: schema.input,
+        output_schema: schema.output,
+        state_schema: schema.state,
+        config_schema: schema.config,
+        // From JS PoV `configSchema` and `contextSchema` are indistinguishable,
+        // thus we use config_schema for context_schema.
+        context_schema: schema.config,
+    });
+});
+api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z.object({ assistant_id: z.string(), namespace: z.string().optional() })), zValidator("query", z.object({ recurse: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Assistant Subgraphs
+    const { assistant_id, namespace } = c.req.valid("param");
+    const { recurse } = c.req.valid("query");
+    const assistantId = getAssistantId(assistant_id);
+    const assistant = await assistants().get(assistantId, c.var.auth);
+    const config = getRunnableConfig(assistant.config);
+    const graph = await getGraph(assistant.graph_id, config);
+    const result = [];
+    const subgraphsGenerator = "getSubgraphsAsync" in graph
+        ? graph.getSubgraphsAsync.bind(graph)
+        : // @ts-expect-error older versions of langgraph don't have getSubgraphsAsync
+            graph.getSubgraphs.bind(graph);
+    let graphSchemaPromise;
+    for await (const [ns, subgraph] of subgraphsGenerator(namespace, recurse)) {
+        const schema = await (async () => {
+            const runtimeSchema = await getRuntimeGraphSchema(subgraph);
+            if (runtimeSchema)
+                return runtimeSchema;
+            graphSchemaPromise ??= getCachedStaticGraphSchema(assistant.graph_id);
+            const graphSchema = await graphSchemaPromise;
+            const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+            if (!rootGraphId) {
+                throw new HTTPException(404, {
+                    message: "Failed to find root graph",
+                });
+            }
+            return graphSchema[`${rootGraphId}|${ns}`] || graphSchema[rootGraphId];
+        })();
+        result.push([ns, schema]);
+    }
+    return c.json(Object.fromEntries(result));
+});
+api.post("/assistants/:assistant_id/latest", zValidator("json", schemas.AssistantLatestVersion), async (c) => {
+    // Set Latest Assistant Version
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const { version } = c.req.valid("json");
+    return c.json(await assistants().setLatest(assistantId, version, c.var.auth));
+});
+api.post("/assistants/:assistant_id/versions", zValidator("json", z.object({
+    limit: z.number().min(1).max(1000).optional().default(10),
+    offset: z.number().min(0).optional().default(0),
+    metadata: z.record(z.unknown()).optional(),
+})), async (c) => {
+    // Get Assistant Versions
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const { limit, offset, metadata } = c.req.valid("json");
+    const versions = await assistants().getVersions(assistantId, { limit, offset, metadata }, c.var.auth);
+    if (!versions?.length) {
+        throw new HTTPException(404, {
+            message: `Assistant "${assistantId}" not found.`,
+        });
+    }
+    return c.json(versions);
+});
+export default api;

package/dist/api/meta.d.mts

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

package/dist/api/meta.mjs

@@ -0,0 +1,65 @@
+import { Hono } from "hono";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as url from "node:url";
+const api = new Hono();
+// Get the version using the same pattern as semver/index.mts
+const packageJsonPath = path.resolve(url.fileURLToPath(import.meta.url), "../../../package.json");
+let version;
+let langgraph_js_version;
+let versionInfoLoaded = false;
+const loadVersionInfo = async () => {
+    try {
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+        version = packageJson.version;
+    }
+    catch {
+        console.warn("Could not determine version of langgraph-api");
+    }
+    // Get the installed version of @langchain/langgraph
+    try {
+        const langgraphPkg = await import("@langchain/langgraph/package.json");
+        if (langgraphPkg?.default?.version) {
+            langgraph_js_version = langgraphPkg.default.version;
+        }
+    }
+    catch {
+        console.warn("Could not determine version of @langchain/langgraph");
+    }
+};
+// read env variable
+const env = process.env;
+api.get("/info", async (c) => {
+    if (!versionInfoLoaded) {
+        await loadVersionInfo();
+        versionInfoLoaded = true;
+    }
+    const langsmithApiKey = env["LANGSMITH_API_KEY"] || env["LANGCHAIN_API_KEY"];
+    const langsmithTracing = (() => {
+        if (langsmithApiKey) {
+            // Check if any tracing variable is explicitly set to "false"
+            const tracingVars = [
+                env["LANGCHAIN_TRACING_V2"],
+                env["LANGCHAIN_TRACING"],
+                env["LANGSMITH_TRACING_V2"],
+                env["LANGSMITH_TRACING"],
+            ];
+            // Return true unless explicitly disabled
+            return !tracingVars.some((val) => val === "false" || val === "False");
+        }
+        return undefined;
+    })();
+    return c.json({
+        version,
+        langgraph_js_version,
+        context: "js",
+        flags: {
+            assistants: true,
+            crons: false,
+            langsmith: !!langsmithTracing,
+            langsmith_tracing_replicas: true,
+        },
+    });
+});
+api.get("/ok", (c) => c.json({ ok: true }));
+export default api;

package/dist/api/runs.d.mts

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

package/dist/api/runs.mjs

@@ -0,0 +1,324 @@
+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

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