@langchain/langgraph-cli 0.0.0-preview.10

package/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,69 @@
+# LangGraph.js CLI
+
+The official command-line interface for LangGraph.js, providing tools to create, develop, and deploy LangGraph.js applications.
+
+## Installation
+
+The `@langchain/langgraph-cli` is a CLI binary that can be run via `npx` or installed via your package manager of choice:
+
+```bash
+npx @langchain/langgraph-cli
+```
+
+## Commands
+
+### `langgraphjs dev`
+
+Run LangGraph.js API server in development mode with hot reloading.
+
+```bash
+npx @langchain/langgraph-cli dev
+```
+
+### `langgraphjs build`
+
+Build a Docker image for your LangGraph.js application.
+
+```bash
+npx @langchain/langgraph-cli build
+```
+
+### `langgraphjs up`
+
+Run LangGraph.js API server in Docker.
+
+```bash
+npx @langchain/langgraph-cli up
+```
+
+### `langgraphjs dockerfile`
+
+Generate a Dockerfile for custom deployments
+
+```bash
+npx @langchain/langgraph-cli dockerfile <save path>
+```
+
+## Configuration
+
+The CLI uses a `langgraph.json` configuration file with these key settings:
+
+```json5
+{
+  // Required: Graph definitions
+  "graphs": {
+    "graph": "./src/graph.ts:graph" 
+  },
+
+  // Optional: Node version (20 only at the moment)
+  "node_version": "20",
+
+  // Optional: Environment variables
+  "env": ".env",
+  
+  // Optional: Additional Dockerfile commands
+  "dockerfile_lines": []
+}
+```
+
+See the [full documentation](https://langchain-ai.github.io/langgraph/cloud/reference/cli) for detailed configuration options.

package/dist/api/assistants.mjs

@@ -0,0 +1,144 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import { v4 as uuid } from "uuid";
+import { z } from "zod";
+import { getAssistantId, getGraph, getGraphSchema } from "../graph/load.mjs";
+import { Assistants } from "../storage/ops.mjs";
+import * as schemas from "../schemas.mjs";
+import { HTTPException } from "hono/http-exception";
+const api = new Hono();
+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 ?? {},
+        graph_id: payload.graph_id,
+        metadata: payload.metadata ?? {},
+        if_exists: payload.if_exists ?? "raise",
+        name: payload.name ?? "Untitled",
+    });
+    return c.json(assistant);
+});
+api.post("/assistants/search", zValidator("json", schemas.AssistantSearchRequest), async (c) => {
+    // Search Assistants
+    const payload = c.req.valid("json");
+    const result = [];
+    for await (const item of Assistants.search({
+        graph_id: payload.graph_id,
+        metadata: payload.metadata,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+    })) {
+        result.push(item);
+    }
+    return c.json(result);
+});
+api.get("/assistants/:assistant_id", async (c) => {
+    // Get Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await Assistants.get(assistantId));
+});
+api.delete("/assistants/:assistant_id", async (c) => {
+    // Delete Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await Assistants.delete(assistantId));
+});
+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));
+});
+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.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);
+    const { xray } = c.req.valid("query");
+    const graph = getGraph(assistant.graph_id);
+    return c.json(graph.getGraph({ ...getRunnableConfig(assistant.config), xray }).toJSON());
+});
+api.get("/assistants/:assistant_id/schemas", async (c) => {
+    // Get Assistant Schemas
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const assistant = await Assistants.get(assistantId);
+    const graphSchema = await getGraphSchema(assistant.graph_id);
+    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+    if (!rootGraphId)
+        throw new Error("Failed to find root graph");
+    const rootGraphSchema = graphSchema[rootGraphId];
+    return c.json({
+        graph_id: assistant.graph_id,
+        input_schema: rootGraphSchema.input,
+        output_schema: rootGraphSchema.output,
+        state_schema: rootGraphSchema.state,
+        config_schema: rootGraphSchema.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);
+    const graph = getGraph(assistant.graph_id);
+    const graphSchema = await getGraphSchema(assistant.graph_id);
+    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+    if (!rootGraphId) {
+        throw new HTTPException(404, { message: "Failed to find root graph" });
+    }
+    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);
+    for await (const [ns] of subgraphsGenerator(namespace, recurse)) {
+        result.push([
+            ns,
+            graphSchema[`${rootGraphId}|${ns}`] || graphSchema[rootGraphId],
+        ]);
+    }
+    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));
+});
+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");
+    return c.json(await Assistants.getVersions(assistantId, {
+        limit,
+        offset,
+        metadata,
+    }));
+});
+export default api;

package/dist/api/runs.mjs

@@ -0,0 +1,239 @@
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { streamSSE } from "hono/streaming";
+import { getAssistantId } from "../graph/load.mjs";
+import { zValidator } from "@hono/zod-validator";
+import * as schemas from "../schemas.mjs";
+import { z } from "zod";
+import { Runs, Threads } from "../storage/ops.mjs";
+import { serialiseAsDict } from "../utils/serde.mjs";
+import { getDisconnectAbortSignal, jsonExtra, waitKeepAlive, } from "../utils/hono.mjs";
+import { logError, logger } from "../logging.mjs";
+import { v4 as uuid4 } from "uuid";
+const api = new Hono();
+const createValidRun = async (threadId, payload) => {
+    const { assistant_id: assistantId, ...run } = payload;
+    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);
+    }
+    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,
+        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,
+    }, {
+        threadId,
+        metadata: run.metadata,
+        status: "pending",
+        multitaskStrategy,
+        preventInsertInInflight,
+        afterSeconds: payload.after_seconds,
+        ifNotExists: payload.if_not_exists,
+    });
+    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 });
+            }
+            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 Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    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 })) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logError(error, { prefix: "Error streaming run" });
+        }
+    });
+});
+api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
+    // Wait Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    return waitKeepAlive(c, Runs.wait(run.run_id, undefined));
+});
+api.post("/runs", zValidator("json", schemas.RunCreate), async (c) => {
+    // Create Stateless Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    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)));
+    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 [runs] = await Promise.all([
+        Runs.search(thread_id, {
+            limit,
+            offset,
+            status,
+            metadata,
+        }),
+        Threads.get(thread_id),
+    ]);
+    return jsonExtra(c, runs);
+});
+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);
+    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);
+    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, thread_id, { cancelOnDisconnect })) {
+                await stream.writeSSE({ 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);
+    return waitKeepAlive(c, Runs.join(run.run_id, thread_id));
+});
+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),
+        Threads.get(thread_id),
+    ]);
+    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);
+    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));
+});
+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");
+    return streamSSE(c, async (stream) => {
+        const signal = cancel_on_disconnect
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        for await (const { event, data } of Runs.Stream.join(run_id, thread_id, {
+            cancelOnDisconnect: signal,
+        })) {
+            await stream.writeSSE({ 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 });
+    if (wait)
+        await Runs.join(run_id, thread_id);
+    return c.body(null, wait ? 204 : 202);
+});
+export default api;

package/dist/api/store.mjs

@@ -0,0 +1,83 @@
+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";
+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);
+    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);
+    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 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 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");
+    const key = payload.key;
+    const namespace = payload.namespace;
+    return c.json(mapItemsToApi(await storageStore.get(namespace, key)));
+});
+export default api;