@langchain/langgraph-api 1.2.2 → 1.2.4

package/dist/src/api/protocol.mjs

@@ -1,157 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
-import { v7 as uuid7 } from "uuid";
-import { z } from "zod/v3";
-import { ProtocolService } from "../protocol/service.mjs";
-import { jsonExtra } from "../utils/hono.mjs";
-import { serialiseAsDict } from "../utils/serde.mjs";
-const ThreadIdSchema = z.object({ thread_id: z.string() });
-const EventsFilterSchema = z
-    .object({
-    channels: z.array(z.string()),
-    namespaces: z.array(z.array(z.string())).optional(),
-    depth: z.number().int().nonnegative().optional(),
-    since: z.number().int().nonnegative().optional(),
-})
-    .strict();
-const ProtocolCommandSchema = z.object({
-    id: z.number().int().nonnegative(),
-    method: z.string(),
-    params: z.record(z.unknown()).optional(),
-});
-/**
- * Normalize browser/node websocket message payloads into UTF-8 text so the
- * protocol layer only needs to handle JSON strings.
- */
-const parseSocketPayload = async (event) => {
-    if (typeof event.data === "string")
-        return event.data;
-    if (event.data instanceof ArrayBuffer) {
-        return new TextDecoder().decode(new Uint8Array(event.data));
-    }
-    if (event.data instanceof Blob) {
-        const buffer = await event.data.arrayBuffer();
-        return new TextDecoder().decode(new Uint8Array(buffer));
-    }
-    return String(event.data);
-};
-/**
- * Register thread-centric protocol transport routes for LangGraph API.
- */
-export default function createProtocolApi(upgradeWebSocket, ops) {
-    const api = new Hono();
-    const protocolService = new ProtocolService({
-        runs: ops.runs,
-        threads: ops.threads,
-    });
-    api.get("/threads/:thread_id/stream/events", zValidator("param", ThreadIdSchema), upgradeWebSocket((c) => {
-        const { thread_id } = c.req.valid("param");
-        const record = protocolService.ensureThread({
-            threadId: thread_id,
-            transport: "websocket",
-            auth: c.var.auth,
-        });
-        return {
-            async onOpen(_event, ws) {
-                await protocolService.attachEventSink(thread_id, (event) => {
-                    ws.send(serialiseAsDict(event));
-                });
-            },
-            async onMessage(event, ws) {
-                let payload;
-                try {
-                    payload = JSON.parse(await parseSocketPayload(event));
-                }
-                catch {
-                    ws.send(serialiseAsDict({
-                        type: "error",
-                        id: null,
-                        error: "invalid_argument",
-                        message: "Protocol commands must be valid JSON.",
-                    }));
-                    return;
-                }
-                if (typeof payload !== "object" ||
-                    payload == null ||
-                    typeof payload.id !== "number" ||
-                    typeof payload.method !== "string") {
-                    ws.send(serialiseAsDict({
-                        type: "error",
-                        id: null,
-                        error: "invalid_argument",
-                        message: "Protocol commands must include an integer id and string method.",
-                    }));
-                    return;
-                }
-                const response = await protocolService.handleCommand(record.threadId, payload);
-                // `null` means the session already wrote the response through
-                // the shared transport queue (see
-                // `ProtocolSession.handleSubscribeForResponse`). Sending again
-                // here would double-deliver the success and break ordering.
-                if (response != null) {
-                    ws.send(serialiseAsDict(response));
-                }
-            },
-            onClose() {
-                void protocolService.closeThread(record.threadId);
-            },
-            onError() {
-                void protocolService.closeThread(record.threadId);
-            },
-        };
-    }));
-    api.post("/threads/:thread_id/commands", zValidator("param", ThreadIdSchema), zValidator("json", ProtocolCommandSchema), async (c) => {
-        const { thread_id } = c.req.valid("param");
-        protocolService.ensureThread({
-            threadId: thread_id,
-            transport: "sse-http",
-            auth: c.var.auth,
-        });
-        const payload = c.req.valid("json");
-        return jsonExtra(c, await protocolService.handleCommand(thread_id, payload));
-    });
-    api.post("/threads/:thread_id/stream/events", zValidator("param", ThreadIdSchema), zValidator("json", EventsFilterSchema), async (c) => {
-        const { thread_id } = c.req.valid("param");
-        protocolService.ensureThread({
-            threadId: thread_id,
-            transport: "sse-http",
-            auth: c.var.auth,
-        });
-        const body = c.req.valid("json");
-        const sinkId = uuid7();
-        const filter = {
-            channels: new Set(body.channels),
-            namespaces: body.namespaces,
-            depth: body.depth,
-            since: body.since,
-        };
-        return streamSSE(c, async (stream) => {
-            const delivered = new Set();
-            const writeSse = async (event) => {
-                if (event.event_id == null)
-                    return;
-                if (delivered.has(event.event_id))
-                    return;
-                delivered.add(event.event_id);
-                await stream.writeSSE({
-                    id: event.event_id,
-                    event: event.method,
-                    data: serialiseAsDict(event),
-                });
-            };
-            await protocolService.attachFilteredEventSink(thread_id, {
-                id: sinkId,
-                filter,
-                send: writeSse,
-            });
-            stream.onAbort(() => {
-                protocolService.detachEventSink(thread_id, sinkId);
-            });
-            await new Promise((resolve) => {
-                stream.onAbort(() => resolve());
-            });
-        });
-    });
-    return api;
-}

package/dist/src/api/runs.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/src/api/runs.mjs

@@ -1,335 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { HTTPException } from "hono/http-exception";
-import { streamSSE } from "hono/streaming";
-import { v7 as uuid7 } 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 = uuid7();
-    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, {
-                signal: cancelOnDisconnect,
-                cancelOnDisconnect: cancelOnDisconnect != null,
-                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, {
-                signal: cancelOnDisconnect,
-                cancelOnDisconnect: cancelOnDisconnect != null,
-                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, {
-                signal: cancelOnDisconnect,
-                cancelOnDisconnect: cancelOnDisconnect != null,
-                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, {
-            signal,
-            cancelOnDisconnect: signal != null,
-            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/src/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/src/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/src/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;