@alexanderolsen/create-deepagent 0.1.0

package/registry/frameworks/deno/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.ts";
+
+/**
+ * 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/deno.ts

@@ -0,0 +1,17 @@
+import { createFramework } from "../../src/registry/framework.js";
+
+export const deno = createFramework({
+  id: "deno",
+  title: "Deno",
+  defaultProjectName: "deno-deepagents",
+  address: {
+    scheme: "github",
+    owner: "aolsenjazz",
+    repo: "deployment-cookbook",
+    subPath: "js-deno",
+  },
+  envFilePath: ".env",
+  packageJsonPath: "package.json",
+  agentPath: "server/agent",
+  files: [],
+});

package/registry/frameworks/hono/.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/hono/README.md

@@ -0,0 +1,186 @@
+# Deploying a LangChain Agent with Cloudflare Workers
+
+An example app that deploys a LangChain **deep agent** on
+[Cloudflare Workers](https://developers.cloudflare.com/workers/) — 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 Worker
+routes (HTTP + SSE). The React SPA is served from the same Worker via
+[Workers Assets](https://developers.cloudflare.com/workers/static-assets/). No
+separate backend process — one Worker serves the SPA and the protocol API.
+
+## Deploy to Cloudflare
+
+1. Install dependencies and build:
+
+   ```bash
+   cd js-cloudflare
+   cp .env.example .dev.vars   # set OPENAI_API_KEY for local dev
+   pnpm install
+   pnpm build
+   ```
+
+2. Log in and set your secret:
+
+   ```bash
+   npx wrangler login
+   npx wrangler secret put OPENAI_API_KEY
+   ```
+
+3. Deploy:
+
+   ```bash
+   pnpm run deploy
+   ```
+
+Wrangler uploads the Vite build (SPA) and the Worker script in one deploy.
+`nodejs_compat` and `nodejs_compat_populate_process_env` are enabled so LangChain
+can read `OPENAI_API_KEY` from the environment.
+
+`wrangler.jsonc` registers the `ThreadSession` Durable Object with
+`new_sqlite_classes`, which is required on the Workers **Free** plan (error
+`10097` if you use the legacy `new_classes` migration instead).
+
+Optionally enable LangSmith tracing by adding the variables from
+[`.env.example`](./.env.example) as Worker secrets or vars.
+
+## Required API endpoints
+
+The app exposes the Agent Streaming Protocol under `/api/threads/...`. Routes
+are implemented in `worker/index.ts` with [Hono](https://hono.dev).
+
+### Minimum (streaming chat)
+
+| 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                   |
+
+### Optional (sidebar)
+
+| 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              |
+
+### Request flow
+
+```mermaid
+flowchart TB
+  subgraph browser["Browser (Vite + React)"]
+    SP["StreamProvider"]
+    HAA["HttpAgentServerAdapter"]
+    SP --- HAA
+  end
+
+  subgraph worker["Cloudflare Worker (Hono)"]
+    CMD["POST /api/threads/:id/commands"]
+    STR["POST /api/threads/:id/stream"]
+    STA["GET|POST /api/threads/:id/state"]
+    RUN["startAgentRun"]
+  end
+
+  subgraph do["Durable Object (per thread)"]
+    LOG["StreamChannel event log"]
+    SSE["SSE subscriptions"]
+  end
+
+  subgraph agent["worker/agent"]
+    AGT["createDeepAgent + MemorySaver"]
+  end
+
+  HAA -->|POST| CMD
+  HAA -->|POST| STR
+  HAA -->|GET / POST| STA
+  CMD --> RUN
+  RUN --> AGT
+  RUN -->|publish events| LOG
+  STR --> SSE
+  LOG --> SSE
+  STA --> 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 Worker starts the graph run and fans each protocol event into the
+   thread's **Durable Object**.
+4. The SDK subscribes to `/stream` (SSE). The DO replays buffered events and
+   stays attached for live frames — even across Worker isolate restarts.
+5. Subagent (`task`) runs emit namespaced events surfaced as `stream.subagents`.
+
+## Cloudflare backend design
+
+| Concern       | Implementation                                          |
+| ------------- | ------------------------------------------------------- |
+| Frontend      | Vite + React SPA (`src/`)                               |
+| API layer     | Hono routes in `worker/index.ts`                        |
+| Runtime       | Workers V8 + `nodejs_compat`                            |
+| SSE replay    | Per-thread **Durable Object** (`ThreadSession`)         |
+| Agent runs    | Worker isolate; protocol events POSTed to the DO        |
+| Static assets | Workers Assets (`wrangler.jsonc` → `assets`)            |
+| Secrets       | `wrangler secret` / `.dev.vars`                         |
+| Local dev     | `vite` (Cloudflare Vite plugin runs the Worker runtime) |
+
+The split between **Worker** (agent + checkpointer) and **Durable Object** (SSE
+event log) is the main design choice on Cloudflare. Worker isolates are
+ephemeral, so replay buffers live in Durable Objects rather than process memory.
+
+## Production persistence
+
+Out of the box, the agent uses an in-memory `MemorySaver` checkpointer
+(`worker/agent/index.ts`). That works for local dev and demos, but on Cloudflare
+(multiple isolates, cold starts) conversation state is **not durable** across
+deploys or isolates.
+
+For production:
+
+1. Swap in a [durable checkpointer](https://docs.langchain.com/oss/javascript/langgraph/checkpointers#checkpointer-libraries)
+   (for example Postgres via Hyperdrive, or a custom DO-backed store).
+2. Keep per-thread Durable Objects for SSE replay (or persist the event log to
+   DO storage / KV for long-lived reconnects).
+
+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 .dev.vars   # set OPENAI_API_KEY
+pnpm install
+pnpm dev
+```
+
+Open [http://localhost:5173](http://localhost:5173). The Cloudflare Vite plugin
+runs your Worker in the Workers runtime during dev, so `/api/*` routes behave
+like production.
+
+```bash
+pnpm build    # production build (client + worker)
+pnpm preview  # preview the production build locally
+pnpm typecheck
+```
+
+## Project layout
+
+- `src/components/` — chat UI (`ChatApp`, `Chat`, `MessageThread`, `Subagents`,
+  `ThreadHistory`, …).
+- `src/lib/chat/threads-client.ts` — browser thread bootstrap and sidebar helpers.
+- `worker/agent/` — deep agent (`createDeepAgent`) with `researcher` and
+  `math-whiz` subagents and mock tools.
+- `worker/server/` — protocol helpers: `runs.ts` (start runs on the Worker),
+  `threads.ts` (checkpointer-backed state), `serialize.ts`, `registry.ts`.
+- `worker/durable-objects/thread-session.ts` — per-thread SSE event log
+  (`StreamChannel` + `matchesSubscription`).
+- `worker/index.ts` — Hono app: protocol routes + Worker export.
+- `wrangler.jsonc` — Worker config: `nodejs_compat`, Durable Object bindings,
+  SPA asset routing (`run_worker_first: ["/api/*"]`).
+
+## 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
+- [Cloudflare Workers](https://developers.cloudflare.com/workers/) — edge runtime and deployment
+- [Durable Objects](https://developers.cloudflare.com/durable-objects/) — per-thread SSE replay storage
+- [Workers Assets](https://developers.cloudflare.com/workers/static-assets/) — SPA hosting from the same Worker
+- [`deepagents`](https://www.npmjs.com/package/deepagents) — coordinator + subagent orchestration used by this demo

package/registry/frameworks/hono/index.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en" class="h-full antialiased">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>LangChain Deep Agent · Cloudflare Workers</title>
+    <meta
+      name="description"
+      content="Deploying a LangChain deep agent with Cloudflare Workers: streaming chat, subagents, and per-thread history."
+    />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Geist+Mono:wght@400;500&family=Geist:wght@400;500;600&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body class="min-h-full">
+    <div id="root" class="h-full"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/registry/frameworks/hono/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "hono-deepagents",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "deploy": "pnpm build && wrangler deploy",
+    "typecheck": "tsc -b --noEmit",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@langchain/core": "^1.2.1",
+    "@langchain/langgraph": "^1.3.7",
+    "@langchain/langgraph-sdk": "^1.9.20",
+    "@langchain/openai": "^1.4.7",
+    "@langchain/protocol": "^0.0.16",
+    "@langchain/react": "^1.0.20",
+    "deepagents": "^1.10.2",
+    "hono": "^4.11.4",
+    "langchain": "^1.4.4",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "^1.7.0",
+    "@cloudflare/workers-types": "^4.20250613.0",
+    "@tailwindcss/vite": "^4.1.11",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@vitejs/plugin-react": "^5.1.0",
+    "eslint": "^9",
+    "tailwindcss": "^4",
+    "typescript": "^5",
+    "vite": "^7.1.12",
+    "wrangler": "^4.20.0"
+  },
+  "packageManager": "pnpm@10.29.2"
+}