@alexanderolsen/create-deepagent 0.1.0

package/registry/frameworks/hono/worker/server/threads.ts

@@ -0,0 +1,404 @@
+/**
+ * Thread state helpers backed by the graph checkpointer.
+ *
+ * Implements the LangGraph SDK thread state wire-shape consumed by
+ * `client.threads.getState` / `updateState` (`GET|POST /threads/:id/state`) and
+ * `getHistory` (`POST /threads/:id/history`), aligned with the Agent Protocol
+ * thread model.
+ */
+
+import type { MemorySaver } from "@langchain/langgraph";
+import type { CompiledGraphType } from "@langchain/langgraph";
+import type { RunnableConfig } from "@langchain/core/runnables";
+
+import { isRecord, sanitizeForJson } from "./serialize";
+
+/**
+ * Compiled LangGraph instance exposed through the custom protocol server.
+ *
+ * Thread routes read and write checkpointed state through this graph's
+ * checkpointer rather than maintaining a separate thread store.
+ */
+export type LocalProtocolGraph = CompiledGraphType;
+
+type StateSnapshot = Awaited<ReturnType<LocalProtocolGraph["getState"]>>;
+
+/**
+ * Raised when a thread has no checkpoint yet.
+ *
+ * The route handlers map this to HTTP 404 so the LangGraph SDK can bootstrap
+ * the thread via `POST /threads/:id/state` before the first run.
+ */
+export class ThreadNotFoundError extends Error {
+  readonly threadId: string;
+
+  constructor(threadId: string) {
+    super(`Thread ${threadId} not found`);
+    this.name = "ThreadNotFoundError";
+    this.threadId = threadId;
+  }
+}
+
+/**
+ * Graph node used when bootstrapping an empty thread.
+ *
+ * Empty `messages` updates must land on `__start__` so conditional edges are
+ * not evaluated before the first human turn exists.
+ */
+const INITIAL_UPDATE_NODE = "__start__";
+
+/**
+ * Default graph node for non-empty state updates on an existing checkpoint.
+ *
+ * Matches the agent's model node when the client omits `as_node`.
+ */
+const DEFAULT_UPDATE_NODE = "model_request";
+
+/** Build the {@link RunnableConfig} that scopes graph calls to a thread id. */
+function threadConfig(threadId: string): RunnableConfig {
+  return { configurable: { thread_id: threadId } };
+}
+
+/**
+ * Build the config passed to `getStateHistory` for root or subgraph-scoped
+ * history, matching langgraph-api's `{ thread_id, checkpoint_ns: "", ...checkpoint }`.
+ */
+function historyConfig(
+  threadId: string,
+  checkpoint?: Record<string, unknown> | null,
+): RunnableConfig {
+  const configurable: Record<string, unknown> = {
+    thread_id: threadId,
+    checkpoint_ns: "",
+  };
+  if (checkpoint && isRecord(checkpoint)) {
+    Object.assign(configurable, checkpoint);
+  }
+  return { configurable };
+}
+
+/** Read the `configurable` bag from a LangGraph run config. */
+function configurableOf(config: RunnableConfig): Record<string, unknown> {
+  return isRecord(config.configurable) ? config.configurable : {};
+}
+
+/**
+ * Return whether a {@link StateSnapshot} represents a persisted checkpoint.
+ *
+ * LangGraph returns an empty configurable bag before the first write; the SDK
+ * treats that as "thread not found" rather than an empty thread state.
+ */
+function threadHasCheckpoint(snapshot: StateSnapshot): boolean {
+  const checkpointId = configurableOf(snapshot.config).checkpoint_id;
+  return typeof checkpointId === "string" && checkpointId.length > 0;
+}
+
+function isStateSnapshot(state: unknown): state is StateSnapshot {
+  return isRecord(state) && "values" in state && "next" in state;
+}
+
+function serializeTaskError(error: unknown): string | null {
+  if (error == null) return null;
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+
+/** Map a LangGraph run config to the SDK checkpoint wire shape. */
+function runnableConfigToCheckpoint(
+  config: RunnableConfig | null | undefined,
+  fallbackThreadId?: string,
+): Record<string, unknown> | null {
+  if (!config || !isRecord(config.configurable)) return null;
+  const c = config.configurable;
+  const thread_id =
+    typeof c.thread_id === "string" ? c.thread_id : fallbackThreadId;
+  if (!thread_id || typeof c.checkpoint_id !== "string") return null;
+
+  return {
+    thread_id,
+    checkpoint_id: c.checkpoint_id,
+    checkpoint_ns: typeof c.checkpoint_ns === "string" ? c.checkpoint_ns : "",
+    checkpoint_map: isRecord(c.checkpoint_map) ? c.checkpoint_map : null,
+  };
+}
+
+function taskCheckpointFromState(
+  state: unknown,
+): Record<string, unknown> | null {
+  if (state == null || !isRecord(state) || !isRecord(state.configurable)) {
+    return null;
+  }
+  const c = state.configurable;
+  if (typeof c.thread_id !== "string") return null;
+  return {
+    thread_id: c.thread_id,
+    checkpoint_id: typeof c.checkpoint_id === "string" ? c.checkpoint_id : null,
+    checkpoint_ns: typeof c.checkpoint_ns === "string" ? c.checkpoint_ns : "",
+    checkpoint_map: isRecord(c.checkpoint_map) ? c.checkpoint_map : null,
+  };
+}
+
+/**
+ * Serialize a LangGraph {@link StateSnapshot} to the SDK `ThreadState` shape.
+ *
+ * Aligned with langgraph-api's `stateSnapshotToThreadState`, plus
+ * {@link sanitizeForJson} on `values` and nested task `result` payloads.
+ */
+export function serializeThreadState(
+  snapshot: StateSnapshot,
+  threadId: string,
+): Record<string, unknown> {
+  const configurable = configurableOf(snapshot.config);
+  const checkpoint = runnableConfigToCheckpoint(snapshot.config, threadId) ?? {
+    thread_id: threadId,
+    checkpoint_id:
+      typeof configurable.checkpoint_id === "string"
+        ? configurable.checkpoint_id
+        : null,
+    checkpoint_ns:
+      typeof configurable.checkpoint_ns === "string"
+        ? configurable.checkpoint_ns
+        : "",
+    checkpoint_map: null,
+  };
+
+  const tasks = (snapshot.tasks ?? []).map((task) => {
+    const record = task as {
+      id?: unknown;
+      name?: unknown;
+      error?: unknown;
+      interrupts?: unknown;
+      path?: unknown;
+      result?: unknown;
+      state?: unknown;
+    };
+    return {
+      id: record.id,
+      name: record.name,
+      error: serializeTaskError(record.error),
+      interrupts: Array.isArray(record.interrupts) ? record.interrupts : [],
+      path: record.path ?? null,
+      checkpoint: taskCheckpointFromState(record.state),
+      state:
+        record.state != null && isStateSnapshot(record.state)
+          ? serializeThreadState(record.state, threadId)
+          : null,
+      result: record.result != null ? sanitizeForJson(record.result) : null,
+    };
+  });
+
+  const parentConfig = (snapshot as { parentConfig?: RunnableConfig })
+    .parentConfig;
+
+  return {
+    values: sanitizeForJson(snapshot.values ?? {}),
+    next: [...(snapshot.next ?? [])],
+    tasks,
+    checkpoint,
+    metadata: { ...snapshot.metadata },
+    created_at: snapshot.createdAt ?? null,
+    parent_checkpoint: runnableConfigToCheckpoint(parentConfig, threadId),
+  };
+}
+
+/** Summary of a thread for the history sidebar. */
+export type ThreadSummary = {
+  id: string;
+  title: string;
+  updatedAt: string | null;
+};
+
+const UNTITLED = "New conversation";
+
+/** Derive a sidebar title from the first human message in a thread. */
+function deriveTitle(values: unknown): string {
+  if (!isRecord(values) || !Array.isArray(values.messages)) return UNTITLED;
+  for (const message of values.messages) {
+    if (!isRecord(message) || message.type !== "human") continue;
+    const { content } = message;
+    const text =
+      typeof content === "string"
+        ? content
+        : Array.isArray(content)
+          ? content
+              .map((block) =>
+                isRecord(block) && typeof block.text === "string"
+                  ? block.text
+                  : "",
+              )
+              .join("")
+          : "";
+    const trimmed = text.trim();
+    if (trimmed) return trimmed.slice(0, 80);
+  }
+  return UNTITLED;
+}
+
+/**
+ * List every thread known to the checkpointer, newest first.
+ *
+ * The checkpointer is the single source of truth: thread ids are the top-level
+ * keys of {@link MemorySaver.storage}, and each thread's title/timestamp is
+ * derived from its latest checkpoint. Restarting the server clears all of this.
+ */
+export async function listThreads(
+  graph: LocalProtocolGraph,
+  checkpointer: MemorySaver,
+): Promise<ThreadSummary[]> {
+  const ids = Object.keys(checkpointer.storage);
+  const summaries: ThreadSummary[] = [];
+  for (const id of ids) {
+    try {
+      const state = await getThreadState(graph, id);
+      summaries.push({
+        id,
+        title: deriveTitle(state.values),
+        updatedAt:
+          typeof state.created_at === "string" ? state.created_at : null,
+      });
+    } catch {
+      // Skip threads without a readable checkpoint.
+    }
+  }
+  summaries.sort((a, b) =>
+    (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""),
+  );
+  return summaries;
+}
+
+/**
+ * Read checkpointed thread state for `GET /threads/:threadId/state`.
+ *
+ * @throws {@link ThreadNotFoundError} When the thread has no checkpoint yet.
+ */
+export async function getThreadState(
+  graph: LocalProtocolGraph,
+  threadId: string,
+): Promise<Record<string, unknown>> {
+  const snapshot = await graph.getState(threadConfig(threadId));
+  if (!threadHasCheckpoint(snapshot)) throw new ThreadNotFoundError(threadId);
+  return serializeThreadState(snapshot, threadId);
+}
+
+/**
+ * Parse the `before` pagination cursor accepted by `POST /threads/:id/history`.
+ */
+function parseBeforeCursor(
+  threadId: string,
+  before: unknown,
+): RunnableConfig | undefined {
+  if (before == null) return undefined;
+  if (typeof before === "string") {
+    return { configurable: { thread_id: threadId, checkpoint_id: before } };
+  }
+  if (!isRecord(before)) return undefined;
+
+  if (isRecord(before.configurable)) {
+    return {
+      configurable: { thread_id: threadId, ...before.configurable },
+    };
+  }
+
+  const checkpointId = before.checkpoint_id;
+  if (typeof checkpointId !== "string") return undefined;
+
+  const cursor: RunnableConfig = {
+    configurable: { thread_id: threadId, checkpoint_id: checkpointId },
+  };
+  if (typeof before.checkpoint_ns === "string") {
+    (cursor.configurable as Record<string, unknown>).checkpoint_ns =
+      before.checkpoint_ns;
+  }
+  return cursor;
+}
+
+/**
+ * List past thread states for `POST /threads/:threadId/history`.
+ *
+ * @throws {@link ThreadNotFoundError} When the thread has no checkpoint yet.
+ */
+export async function getThreadHistory(
+  graph: LocalProtocolGraph,
+  threadId: string,
+  options: {
+    limit?: number;
+    before?: unknown;
+    metadata?: Record<string, unknown>;
+    checkpoint?: Record<string, unknown> | null;
+  } = {},
+): Promise<Record<string, unknown>[]> {
+  await getThreadState(graph, threadId);
+
+  const history: Record<string, unknown>[] = [];
+  const iterator = graph.getStateHistory(
+    historyConfig(threadId, options.checkpoint),
+    {
+      before: parseBeforeCursor(threadId, options.before),
+      limit: options.limit ?? 10,
+      ...(options.metadata ? { filter: options.metadata } : {}),
+    },
+  );
+  for await (const snapshot of iterator) {
+    history.push(serializeThreadState(snapshot, threadId));
+  }
+  return history;
+}
+
+/** Choose which graph node should receive an `updateState` write. */
+function resolveUpdateNode(options: {
+  asNode?: string;
+  values: Record<string, unknown> | null;
+  hasCheckpoint: boolean;
+}): string {
+  if (options.asNode) return options.asNode;
+  const messages = options.values?.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return INITIAL_UPDATE_NODE;
+  }
+  if (!options.hasCheckpoint) return INITIAL_UPDATE_NODE;
+  return DEFAULT_UPDATE_NODE;
+}
+
+/**
+ * Create or update thread state for `POST /threads/:threadId/state`.
+ *
+ * Used by the browser bootstrap and by the SDK when hydrating or editing
+ * conversation history. Applies the update at {@link resolveUpdateNode}, then
+ * returns the latest serialized snapshot.
+ */
+export async function updateThreadState(
+  graph: LocalProtocolGraph,
+  threadId: string,
+  options: {
+    values?: Record<string, unknown> | null;
+    checkpoint?: Record<string, unknown> | null;
+    asNode?: string;
+  } = {},
+): Promise<Record<string, unknown>> {
+  let config = threadConfig(threadId);
+  const checkpoint = options.checkpoint;
+  if (checkpoint && typeof checkpoint.checkpoint_id === "string") {
+    config = {
+      configurable: {
+        ...configurableOf(config),
+        checkpoint_id: checkpoint.checkpoint_id,
+        ...(typeof checkpoint.checkpoint_ns === "string"
+          ? { checkpoint_ns: checkpoint.checkpoint_ns }
+          : {}),
+      },
+    };
+  }
+
+  const snapshot = await graph.getState(config);
+  const resolvedValues = options.values ?? { messages: [] };
+  const resolvedAsNode = resolveUpdateNode({
+    asNode: options.asNode,
+    values: resolvedValues,
+    hasCheckpoint: threadHasCheckpoint(snapshot),
+  });
+
+  await graph.updateState(config, resolvedValues, resolvedAsNode);
+  const updated = await graph.getState(threadConfig(threadId));
+  return serializeThreadState(updated, threadId);
+}

package/registry/frameworks/hono/worker/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig.worker.json",
+  "include": ["."]
+}

package/registry/frameworks/hono/wrangler.jsonc

@@ -0,0 +1,28 @@
+{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "js-cloudflare",
+  "main": "./worker/index.ts",
+  "compatibility_date": "2026-06-15",
+  "compatibility_flags": [
+    "nodejs_compat",
+    "nodejs_compat_populate_process_env",
+  ],
+  "assets": {
+    "not_found_handling": "single-page-application",
+    "run_worker_first": ["/api/*"],
+  },
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "SESSIONS",
+        "class_name": "ThreadSession",
+      },
+    ],
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["ThreadSession"],
+    },
+  ],
+}

package/registry/frameworks/hono.ts

@@ -0,0 +1,35 @@
+import { createFramework } from "../../src/registry/framework.js";
+import type { ProviderAwareFile } from "../../src/registry/provider.js";
+
+const ENV_D_TS: ProviderAwareFile = {
+  path: "worker/env.d.ts",
+  getContent: ({ providerConfig }) => {
+    const envVars = providerConfig.env
+      .map((e) => `  ${e.name}: string;`)
+      .join("\n");
+
+    return `interface Env {
+  ASSETS: Fetcher;
+  SESSIONS: DurableObjectNamespace;
+${envVars}
+  [key: string]: string | undefined;
+}
+`;
+  },
+};
+
+export const hono = createFramework({
+  id: "hono",
+  title: "Hono",
+  defaultProjectName: "hono-deepagents",
+  address: {
+    scheme: "github",
+    owner: "aolsenjazz",
+    repo: "deployment-cookbook",
+    subPath: "js-cloudflare",
+  },
+  envFilePath: ".env",
+  packageJsonPath: "package.json",
+  agentPath: "worker/agent",
+  files: [ENV_D_TS],
+});

package/registry/frameworks/next/.env.example

@@ -0,0 +1,6 @@
+# Required: OpenAI API key used by the agent and its subagents.
+OPENAI_API_KEY=sk-...
+
+# Optional: enable LangSmith tracing.
+# LANGSMITH_TRACING=true
+# LANGSMITH_API_KEY=lsv2-...

package/registry/frameworks/next/README.md

@@ -0,0 +1,173 @@
+# Deploying a LangChain Agent with Next.js
+
+An example app that deploys a LangChain **deep agent** entirely inside a Next.js
+App Router project — streaming chat UI, subagents, and thread history, all backed
+by the [Agent Streaming Protocol](https://github.com/langchain-ai/agent-protocol/tree/main/streaming) implemented as
+Next.js Route Handlers (HTTP + SSE). No separate backend process.
+
+## Deploy to Vercel
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Flangchain-ai%2Fdeployment-cookbook&root-directory=js-next&env=OPENAI_API_KEY&envDescription=OpenAI%20API%20key%20for%20the%20agent%20and%20its%20subagents)
+
+1. Click **Deploy with Vercel** (or import
+   [`langchain-ai/deployment-cookbook`](https://github.com/langchain-ai/deployment-cookbook)
+   manually).
+2. Set **Root Directory** to `js-next`.
+3. Add `OPENAI_API_KEY` in project settings.
+4. Deploy.
+
+That is all that is required for a first deploy. The route handlers already set
+`runtime = "nodejs"` and the SSE route sets `dynamic = "force-dynamic"`, which
+Vercel needs for streaming.
+
+Optionally enable LangSmith tracing by adding the variables from
+[`.env.example`](./.env.example).
+
+## Required API endpoints
+
+The app exposes the Agent Streaming Protocol under `/api/threads/...`. Route
+handlers live in `app/api/threads/`.
+
+### Minimum (streaming chat)
+
+These three endpoints are enough to run a single-threaded streaming chat with
+`@langchain/react`'s `HttpAgentServerAdapter`:
+
+| Method         | Path                              | Purpose                                                        |
+| -------------- | --------------------------------- | -------------------------------------------------------------- |
+| `POST`         | `/api/threads/:threadId/commands` | Accept protocol commands (`run.start`, …) and start agent runs |
+| `POST`         | `/api/threads/:threadId/stream`   | SSE stream of protocol events for a run                        |
+| `GET` / `POST` | `/api/threads/:threadId/state`    | Read and bootstrap checkpointed thread state                   |
+
+The client bootstraps a thread with `GET /state` (and `POST /state` on 404) so
+hydration does not 404 before the first message is sent.
+
+### Optional (this app's sidebar)
+
+This example also implements endpoints for the thread-history sidebar. You can
+omit them if your UI does not need multi-thread management:
+
+| Method   | Path                             | Purpose                                       |
+| -------- | -------------------------------- | --------------------------------------------- |
+| `GET`    | `/api/threads`                   | List threads known to the checkpointer        |
+| `DELETE` | `/api/threads/:threadId`         | Delete a thread's session and checkpoints     |
+| `POST`   | `/api/threads/:threadId/history` | Paginated checkpoint history (Agent Protocol) |
+
+### Request flow
+
+```mermaid
+flowchart TB
+  subgraph browser["Browser"]
+    SP["StreamProvider"]
+    HAA["HttpAgentServerAdapter"]
+    SP --- HAA
+  end
+
+  subgraph routes["Next.js Route Handlers (Node runtime)"]
+    CMD["POST /api/threads/:id/commands"]
+    STR["POST /api/threads/:id/stream (SSE)"]
+    STA["GET|POST /api/threads/:id/state"]
+  end
+
+  subgraph server["lib/server"]
+    SRV["session · threads · registry"]
+  end
+
+  subgraph agent["lib/agent"]
+    AGT["createDeepAgent + checkpointer"]
+  end
+
+  HAA -->|POST| CMD
+  HAA -->|POST| STR
+  HAA -->|GET / POST| STA
+  CMD --> SRV
+  STR --> SRV
+  STA --> SRV
+  SRV --> AGT
+```
+
+1. Bootstrap thread state (`GET`/`POST /state`).
+2. On submit, the SDK sends `run.start` to `/commands` and receives a `run_id`.
+3. The SDK subscribes to `/stream` (SSE) for replay + live protocol events.
+4. Subagent (`task`) runs emit namespaced events surfaced as `stream.subagents`.
+
+## Production persistence
+
+Out of the box, the agent uses an in-memory `MemorySaver` checkpointer
+(`lib/agent/index.ts`) and a process-local session map (`lib/server/registry.ts`).
+That works for local dev and single-instance servers, but on Vercel (serverless,
+multiple replicas) conversation state is **not durable** across cold starts or
+instances.
+
+For production, swap in a [durable checkpointer](https://docs.langchain.com/oss/javascript/langgraph/checkpointers#checkpointer-libraries):
+
+| Package                                    | Backend                    |
+| ------------------------------------------ | -------------------------- |
+| `@langchain/langgraph-checkpoint-redis`    | Redis (`RedisSaver`)       |
+| `@langchain/langgraph-checkpoint-postgres` | Postgres (`PostgresSaver`) |
+| `@langchain/langgraph-checkpoint-sqlite`   | SQLite (`SqliteSaver`)     |
+
+Replace `MemorySaver` in `lib/agent/index.ts` and pass the new checkpointer to
+`createDeepAgent`. The route handlers and `lib/server/threads.ts` helpers stay
+the same.
+
+### Redis on Vercel
+
+A common choice for Vercel is Redis via the
+[Marketplace](https://vercel.com/docs/redis) (for example
+[Upstash Redis](https://vercel.com/marketplace/upstash)). Install the
+integration on your Vercel project; credentials are injected as environment
+variables automatically.
+
+Then wire `@langchain/langgraph-checkpoint-redis`:
+
+```ts
+import { RedisSaver } from "@langchain/langgraph-checkpoint-redis";
+
+const checkpointer = await RedisSaver.fromUrl(process.env.REDIS_URL!);
+```
+
+Use the connection string your Redis provider exposes (Upstash provides both
+REST and Redis-protocol URLs — the checkpointer needs the Redis URL).
+
+You will also want a shared session/replay store in `lib/server/registry.ts` so
+SSE reconnection works across serverless invocations. The checkpointer swap is
+the main step for durable thread history; the session store is a separate
+concern for live-run replay.
+
+See also: [checkpointer libraries](https://docs.langchain.com/oss/javascript/langgraph/checkpointers#checkpointer-libraries),
+[add memory / persistence](https://docs.langchain.com/oss/javascript/langgraph/add-memory).
+
+## Local development
+
+```bash
+cp .env.example .env.local   # set OPENAI_API_KEY
+pnpm install
+pnpm dev
+```
+
+Open [http://localhost:3000](http://localhost:3000).
+
+```bash
+pnpm build   # production build
+pnpm start   # serve the production build
+pnpm lint    # eslint
+```
+
+## Project layout
+
+- `lib/agent/` — deep agent (`createDeepAgent`) with `researcher` and `math-whiz`
+  subagents and mock tools. Marked `server-only`.
+- `lib/server/` — protocol server logic: `session.ts` (SSE runs),
+  `threads.ts` (checkpointer-backed state), `serialize.ts`, `registry.ts`.
+- `app/api/threads/` — Route Handlers for the protocol endpoints above.
+- `lib/chat/threads-client.ts` — browser thread bootstrap and sidebar helpers.
+- `components/` — chat UI (`ChatApp`, `Chat`, `MessageList`, `Subagents`,
+  `ThreadHistory`, …).
+
+## References
+
+- [Agent Streaming Protocol](https://github.com/langchain-ai/agent-protocol/tree/main/streaming) — protocol spec consumed by `@langchain/react`'s `HttpAgentServerAdapter`
+- [`react-custom-backend`](https://github.com/langchain-ai/streaming-cookbook) — original Vite + Hono reference for a custom protocol server
+- [Next.js Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers) — API routes used for the protocol endpoints
+- [`deepagents`](https://www.npmjs.com/package/deepagents) — coordinator + subagent orchestration used by this demo

package/registry/frameworks/next/app/api/threads/[threadId]/commands/route.ts

@@ -0,0 +1,21 @@
+import type { Command } from "@langchain/protocol";
+
+import { getSession } from "@/lib/server/registry";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+type Params = { params: Promise<{ threadId: string }> };
+
+/**
+ * `POST /api/threads/:threadId/commands`
+ *
+ * The request body is an Agent Protocol {@link Command}. The response is the
+ * command result emitted by the owning `LocalThreadSession`.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const { threadId } = await params;
+  const command = (await request.json()) as Command;
+  const result = await getSession(threadId).handleCommand(command);
+  return Response.json(result);
+}