@alexanderolsen/create-deepagent 0.1.0

package/registry/frameworks/hono/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.worker.json" }
+  ]
+}

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

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "composite": true,
+    "types": ["@cloudflare/workers-types/latest", "vite/client"]
+  },
+  "include": ["worker"]
+}

package/registry/frameworks/hono/vite.config.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import path from "node:path";
+
+import { cloudflare } from "@cloudflare/vite-plugin";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [react(), tailwindcss(), cloudflare()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src"),
+    },
+  },
+});

package/registry/frameworks/hono/worker/agent/index.ts

@@ -0,0 +1,53 @@
+import { MemorySaver } from "@langchain/langgraph";
+import { ChatOpenAI } from "@langchain/openai";
+import { createDeepAgent } from "deepagents";
+
+import { stripReasoningReplay } from "./middleware";
+import { calculator, searchWeb } from "./tools";
+
+const coordinatorModel = new ChatOpenAI({
+  model: "gpt-5.4-mini",
+  reasoning: { effort: "low", summary: "auto" },
+});
+
+const subagentModel = new ChatOpenAI({ model: "gpt-5.4-mini" });
+
+export const checkpointer = new MemorySaver();
+
+export const agent = createDeepAgent({
+  model: coordinatorModel,
+  middleware: [stripReasoningReplay],
+  checkpointer,
+  subagents: [
+    {
+      name: "researcher",
+      description:
+        "Researches a topic using the search_web tool and reports concise findings.",
+      tools: [searchWeb],
+      model: subagentModel,
+      systemPrompt:
+        "You are the researcher subagent. Use the search_web tool to look up " +
+        "the requested topic, then summarize the findings in two or three " +
+        "sentences. Always call search_web at least once before answering.",
+    },
+    {
+      name: "math-whiz",
+      description:
+        "Performs calculations using the calculator tool and explains the result.",
+      tools: [calculator],
+      model: subagentModel,
+      systemPrompt:
+        "You are the math-whiz subagent. Use the calculator tool to evaluate " +
+        "the requested expression, then state the result clearly. Always call " +
+        "the calculator tool before answering.",
+    },
+  ],
+  systemPrompt:
+    "You are a helpful coordinator. When a request involves looking something " +
+    "up, delegate it to the `researcher` subagent. When it involves math, " +
+    "delegate it to the `math-whiz` subagent. You may run both subagents for a " +
+    "single request. After the subagents respond, combine their results into a " +
+    "short, clearly labeled final answer.",
+});
+
+export type Agent = typeof agent;

package/registry/frameworks/hono/worker/agent/middleware.ts

@@ -0,0 +1,20 @@
+import { AIMessage, type BaseMessage } from "@langchain/core/messages";
+import { createMiddleware } from "langchain";
+
+function sanitizeForReplay(message: BaseMessage): BaseMessage {
+  if (!AIMessage.isInstance(message)) return message;
+
+  return new AIMessage({
+    id: message.id,
+    content: message.content,
+    tool_calls: message.tool_calls,
+    invalid_tool_calls: message.invalid_tool_calls,
+    usage_metadata: message.usage_metadata,
+  });
+}
+
+export const stripReasoningReplay = createMiddleware({
+  name: "StripReasoningReplay",
+  wrapModelCall: async (request, handler) =>
+    handler({ ...request, messages: request.messages.map(sanitizeForReplay) }),
+});

package/registry/frameworks/hono/worker/agent/tools.ts

@@ -0,0 +1,55 @@
+import { tool } from "langchain";
+import { z } from "zod";
+
+export const searchWeb = tool(
+  async ({ query }) => {
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    return JSON.stringify({
+      results: [
+        {
+          title: `Result for: ${query}`,
+          snippet:
+            "LangGraph streaming sends token deltas on the messages channel " +
+            "and tool lifecycle events on the tools channel.",
+        },
+      ],
+    });
+  },
+  {
+    name: "search_web",
+    description: "Search the web for information about a topic.",
+    schema: z.object({ query: z.string().describe("Search query.") }),
+  },
+);
+
+function evaluateExpression(expression: string): number {
+  if (!/^[\d+\-*/().\s]+$/.test(expression)) {
+    throw new Error("Only basic arithmetic is supported.");
+  }
+  const compute = new Function(
+    `"use strict"; return (${expression});`,
+  ) as () => unknown;
+  const result = compute();
+  if (typeof result !== "number" || !Number.isFinite(result)) {
+    throw new Error("Expression did not evaluate to a finite number.");
+  }
+  return result;
+}
+
+export const calculator = tool(
+  async ({ expression }) => {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+      return String(evaluateExpression(expression));
+    } catch (error) {
+      return `Error evaluating: ${expression} (${String(error)})`;
+    }
+  },
+  {
+    name: "calculator",
+    description: "Evaluate a math expression.",
+    schema: z.object({
+      expression: z.string().describe("Math expression to evaluate."),
+    }),
+  },
+);

package/registry/frameworks/hono/worker/durable-objects/thread-session.ts

@@ -0,0 +1,159 @@
+import { DurableObject } from "cloudflare:workers";
+// `StreamChannel` buffers events; `matchesSubscription` is the shared protocol
+// predicate from `@langchain/langgraph/stream` — the same one langgraph-api
+// uses, so this custom transport stays aligned with the production server.
+import {
+  StreamChannel,
+  matchesSubscription,
+  type ProtocolEvent,
+} from "@langchain/langgraph/stream";
+import type { SubscribeParams } from "@langchain/protocol";
+
+import { sanitizeForJson } from "../server/serialize";
+
+/**
+ * Make an event safe to `JSON.stringify` onto the SSE wire.
+ *
+ * Only the protocol payload (`params.data`) and any `params.interrupts` can
+ * carry LangChain message instances, so those are the fields we sanitize into
+ * the plain, role-keyed protocol message shape the SDK expects.
+ */
+function sanitizeEvent(event: ProtocolEvent): ProtocolEvent {
+  const params = event.params as Record<string, unknown>;
+  const sanitizedParams: Record<string, unknown> = {
+    ...params,
+    data: sanitizeForJson(params.data),
+  };
+  if ("interrupts" in params) {
+    sanitizedParams.interrupts = sanitizeForJson(params.interrupts);
+  }
+  return { ...event, params: sanitizedParams } as ProtocolEvent;
+}
+
+/**
+ * Encode an Agent Protocol event as a Server-Sent Event frame.
+ *
+ * When available, `event_id` is mirrored into the SSE `id:` field for
+ * transport-level reconnection. The SDK primarily deduplicates by `event_id`
+ * and replays by `seq`; if an event has no `event_id`, this example falls back
+ * to `seq` as a stable frame id.
+ */
+function encodeSse(event: ProtocolEvent) {
+  const eventId = (event as { event_id?: string }).event_id;
+  const id = eventId ?? (typeof event.seq === "number" ? `${event.seq}` : "");
+  const idLine = id ? `id: ${id}\n` : "";
+  return new TextEncoder().encode(
+    `${idLine}event: message\ndata: ${JSON.stringify(event)}\n\n`,
+  );
+}
+
+const SSE_HEADERS = {
+  "cache-control": "no-cache, no-transform",
+  "content-type": "text/event-stream",
+  connection: "keep-alive",
+  "x-accel-buffering": "no",
+};
+
+/**
+ * Per-thread Durable Object that owns the Agent Streaming Protocol event log.
+ *
+ * Cloudflare Workers cannot keep an in-memory session map like the Node
+ * examples. Instead the Worker runs the LangGraph agent and POSTs each protocol
+ * each protocol event here; browser clients subscribe via `/stream`, which
+ * replays buffered events and stays attached for live frames.
+ *
+ * - `POST /publish` appends a protocol event to the replay log.
+ * - `POST /stream` opens a connection-scoped SSE subscription described by
+ *   `SubscribeParams`.
+ * - `POST /clear` resets the replay buffer when a thread is deleted.
+ *
+ * The implementation is intentionally small. Production servers should persist
+ * threads, enforce concurrency policies, and coordinate replay buffers across
+ * workers.
+ */
+export class ThreadSession extends DurableObject {
+  /**
+   * Per-thread protocol event log.
+   *
+   * A {@link StreamChannel} is LangGraph's buffered, append-only stream with
+   * independent per-consumer cursors. Every event ever published stays
+   * buffered, and each SSE subscription gets its own cursor via
+   * {@link StreamChannel.iterate}, so buffered replay and live delivery are the
+   * same iteration.
+   */
+  readonly #log = StreamChannel.local<ProtocolEvent>();
+
+  /** Monotonic seq across all runs on this thread (graph runs reset at 0). */
+  #nextSeq = 0;
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (request.method === "POST" && url.pathname === "/publish") {
+      const event = (await request.json()) as ProtocolEvent;
+      this.#publish(event);
+      return new Response(null, { status: 204 });
+    }
+
+    if (request.method === "POST" && url.pathname === "/stream") {
+      const params = (await request.json()) as SubscribeParams;
+      return new Response(this.#stream(params), { headers: SSE_HEADERS });
+    }
+
+    if (request.method === "POST" && url.pathname === "/clear") {
+      this.#nextSeq = 0;
+      await this.ctx.storage.deleteAll();
+      return new Response(null, { status: 204 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  }
+
+  #publish(rawEvent: ProtocolEvent) {
+    const seq = this.#nextSeq;
+    this.#nextSeq += 1;
+    const event = sanitizeEvent({
+      ...rawEvent,
+      type: "event",
+      seq,
+    } as ProtocolEvent);
+    this.#log.push(event);
+  }
+
+  /**
+   * Open a connection-scoped SSE subscription for this thread.
+   *
+   * The returned `ReadableStream` first replays buffered events matching the
+   * requested `channels`, `namespaces`, `depth`, and optional `since` cursor,
+   * then stays attached for live events. Closing the HTTP connection releases
+   * this subscription's event-log cursor.
+   */
+  #stream(params: SubscribeParams) {
+    const cursor = this.#log.iterate();
+
+    return new ReadableStream<Uint8Array>({
+      pull: async (controller) => {
+        // Scan forward until we find an event matching this subscription's
+        // filter, enqueue exactly one frame, and return so the channel honors
+        // the consumer's backpressure. `cursor.next()` resolves immediately for
+        // buffered events and suspends once the live edge is reached.
+        for (;;) {
+          const { value: event, done } = await cursor.next();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (matchesSubscription(event, params)) {
+            controller.enqueue(encodeSse(event));
+            return;
+          }
+        }
+      },
+      cancel: () => {
+        void cursor.return?.(undefined);
+      },
+    });
+  }
+}
+
+export default ThreadSession;

package/registry/frameworks/hono/worker/env.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="@cloudflare/workers-types" />
+
+import type {
+  Command,
+  CommandResponse,
+  ErrorResponse,
+} from "@langchain/protocol";
+
+declare global {
+  interface Env {
+    ASSETS: Fetcher;
+    SESSIONS: DurableObjectNamespace;
+    OPENAI_API_KEY?: string;
+  }
+}
+
+export type { Command, CommandResponse, ErrorResponse };

package/registry/frameworks/hono/worker/index.ts

@@ -0,0 +1,140 @@
+import { Hono } from "hono";
+import type {
+  Command,
+  CommandResponse,
+  ErrorResponse,
+} from "@langchain/protocol";
+
+import { ThreadSession } from "./durable-objects/thread-session";
+import {
+  deleteThread,
+  getAgent,
+  getCheckpointer,
+  getSessionStub,
+} from "./server/registry";
+import { parseRunInput, startAgentRun } from "./server/runs";
+import {
+  ThreadNotFoundError,
+  getThreadHistory,
+  getThreadState,
+  listThreads,
+  updateThreadState,
+} from "./server/threads";
+
+export { ThreadSession };
+
+const app = new Hono<{ Bindings: Env }>();
+
+app.get("/api/threads", async (c) => {
+  const threads = await listThreads(getAgent().graph, getCheckpointer());
+  return c.json(threads);
+});
+
+app.delete("/api/threads/:threadId", async (c) => {
+  const threadId = c.req.param("threadId");
+  await deleteThread(c.env, threadId);
+  return c.body(null, 204);
+});
+
+app.post("/api/threads/:threadId/commands", async (c) => {
+  const threadId = c.req.param("threadId");
+  const command = (await c.req.json()) as Command;
+
+  if (command.method !== "run.start") {
+    const error: ErrorResponse = {
+      type: "error",
+      id: command.id,
+      error: "unknown_command",
+      message: `Unsupported command: ${command.method}`,
+    };
+    return c.json(error);
+  }
+
+  const runId = crypto.randomUUID();
+  const input = parseRunInput(command);
+  c.executionCtx.waitUntil(startAgentRun(c.env, threadId, input, runId));
+
+  const response: CommandResponse = {
+    type: "success",
+    id: command.id,
+    result: { run_id: runId },
+  };
+  return c.json(response);
+});
+
+app.post("/api/threads/:threadId/stream", async (c) => {
+  const threadId = c.req.param("threadId");
+  const params = await c.req.json();
+  const stub = getSessionStub(c.env, threadId);
+  return stub.fetch(
+    new Request("https://session/stream", {
+      method: "POST",
+      body: JSON.stringify(params),
+    }),
+  );
+});
+
+app.get("/api/threads/:threadId/state", async (c) => {
+  const threadId = c.req.param("threadId");
+  try {
+    const state = await getThreadState(getAgent().graph, threadId);
+    return c.json(state);
+  } catch (error) {
+    if (error instanceof ThreadNotFoundError) {
+      return c.json({ error: "not_found", message: error.message }, 404);
+    }
+    throw error;
+  }
+});
+
+app.post("/api/threads/:threadId/state", async (c) => {
+  const threadId = c.req.param("threadId");
+  const body = (await c.req.json().catch(() => ({}))) as {
+    values?: Record<string, unknown> | null;
+    checkpoint?: Record<string, unknown> | null;
+    as_node?: string;
+  };
+  try {
+    const state = await updateThreadState(getAgent().graph, threadId, {
+      values: body.values ?? null,
+      checkpoint: body.checkpoint ?? null,
+      asNode: body.as_node,
+    });
+    return c.json(state);
+  } catch (error) {
+    return c.json(
+      { error: "invalid_state_update", message: String(error) },
+      422,
+    );
+  }
+});
+
+app.post("/api/threads/:threadId/history", async (c) => {
+  const threadId = c.req.param("threadId");
+  const body = (await c.req.json().catch(() => ({}))) as {
+    limit?: number;
+    before?: unknown;
+    metadata?: Record<string, unknown>;
+    checkpoint?: Record<string, unknown>;
+  };
+  try {
+    const history = await getThreadHistory(getAgent().graph, threadId, {
+      limit: typeof body.limit === "number" ? body.limit : 10,
+      before: body.before,
+      metadata: body.metadata,
+      checkpoint: body.checkpoint,
+    });
+    return c.json(history);
+  } catch (error) {
+    if (error instanceof ThreadNotFoundError) {
+      return c.json({ error: "not_found", message: error.message }, 404);
+    }
+    throw error;
+  }
+});
+
+export default {
+  fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    return app.fetch(request, env, ctx);
+  },
+};

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

@@ -0,0 +1,39 @@
+import { agent, checkpointer } from "../agent";
+
+/**
+ * Worker-level registry for the compiled agent and checkpointer.
+ *
+ * Unlike Next.js route handlers (one Node process), Cloudflare Workers are
+ * short-lived isolates. The agent and `MemorySaver` checkpointer live here so
+ * thread state routes can read/write checkpoints. SSE replay buffers live in
+ * per-thread Durable Objects (see `durable-objects/thread-session.ts`) rather
+ * than an in-memory session map used by the Node examples.
+ *
+ * NOTE: This is in-memory and process-local within each isolate. Production
+ * deployments need a durable checkpointer and a Durable Object session store.
+ * The wiring here stays the same; only the checkpointer in `worker/agent` and
+ * the session store change.
+ */
+
+/** The shared, compiled agent (and its checkpointer). */
+export function getAgent() {
+  return agent;
+}
+
+/** The shared checkpointer — the single source of truth for threads. */
+export function getCheckpointer() {
+  return checkpointer;
+}
+
+/** Delete a thread: remove its checkpointed state and clear the replay buffer. */
+export async function deleteThread(env: Env, threadId: string): Promise<void> {
+  await checkpointer.deleteThread(threadId);
+  const stub = getSessionStub(env, threadId);
+  await stub.fetch(new Request("https://session/clear", { method: "POST" }));
+}
+
+/** Resolve the per-thread Durable Object stub for SSE replay. */
+export function getSessionStub(env: Env, threadId: string) {
+  const id = env.SESSIONS.idFromName(threadId);
+  return env.SESSIONS.get(id);
+}

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

@@ -0,0 +1,82 @@
+import type { ReactAgent } from "langchain";
+import type { ProtocolEvent } from "@langchain/langgraph/stream";
+
+import { getAgent, getSessionStub } from "./registry";
+import { isRecord, sanitizeForJson } from "./serialize";
+
+// `ReactAgent<any>` accepts both `createAgent` results and `DeepAgent`
+// instances (which carry a specific, non-default type config).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyReactAgent = ReactAgent<any>;
+type AgentRunInput = Parameters<AnyReactAgent["streamEvents"]>[0];
+
+/**
+ * Make an event safe to `JSON.stringify` onto the SSE wire.
+ *
+ * Only the protocol payload (`params.data`) and any `params.interrupts` can
+ * carry LangChain message instances, so those are the fields we sanitize into
+ * the plain, role-keyed protocol message shape the SDK expects.
+ */
+function sanitizeEvent(event: ProtocolEvent): ProtocolEvent {
+  const params = event.params as Record<string, unknown>;
+  const sanitizedParams: Record<string, unknown> = {
+    ...params,
+    data: sanitizeForJson(params.data),
+  };
+  if ("interrupts" in params) {
+    sanitizedParams.interrupts = sanitizeForJson(params.interrupts);
+  }
+  return { ...event, params: sanitizedParams } as ProtocolEvent;
+}
+
+/**
+ * Start an agent run on the Worker and fan protocol events into the thread's
+ * Durable Object for SSE replay.
+ *
+ * The SDK sends `run.start` to the `/commands` route, which calls this helper
+ * and immediately returns a generated `run_id`. Streamed events are published
+ * asynchronously to the thread's Durable Object while clients consume them
+ * through active `/stream` subscriptions.
+ */
+export async function startAgentRun(
+  env: Env,
+  threadId: string,
+  input: unknown,
+  runId: string,
+) {
+  const stub = getSessionStub(env, threadId);
+  const activeAgent = getAgent() as AnyReactAgent;
+
+  // Thread the `thread_id` / `run_id` into the run config so the checkpointer
+  // persists conversation state per thread and downstream events carry the
+  // run identity.
+  const run = await activeAgent.streamEvents(input as AgentRunInput, {
+    version: "v3",
+    configurable: { thread_id: threadId, run_id: runId },
+  });
+
+  try {
+    for await (const rawEvent of run) {
+      const event = sanitizeEvent({
+        ...(rawEvent as ProtocolEvent),
+        type: "event",
+      } as ProtocolEvent);
+      await stub.fetch(
+        new Request("https://session/publish", {
+          method: "POST",
+          body: JSON.stringify(event),
+        }),
+      );
+    }
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+/** Parse the `run.start` command payload accepted by `/commands`. */
+export function parseRunInput(command: {
+  params?: unknown;
+}): AgentRunInput | undefined {
+  if (!isRecord(command.params)) return undefined;
+  return command.params.input as AgentRunInput;
+}

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

@@ -0,0 +1,30 @@
+import { BaseMessage } from "@langchain/core/messages";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+/**
+ * Recursively replace LangChain message instances with plain protocol dicts.
+ *
+ * Uses {@link BaseMessage.isInstance} and {@link BaseMessage.toDict} from
+ * `@langchain/core/messages` — the canonical LangChain serialization primitive.
+ * Message instances surface in `values`/`updates` stream data and in the
+ * checkpointer state snapshot returned by the thread-state routes, often nested
+ * under `messages`.
+ */
+export function sanitizeForJson(value: unknown): unknown {
+  if (BaseMessage.isInstance(value)) {
+    const { type, data } = value.toDict();
+    return sanitizeForJson({ ...data, type });
+  }
+  if (Array.isArray(value)) return value.map(sanitizeForJson);
+  if (isRecord(value)) {
+    const result: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = sanitizeForJson(item);
+    }
+    return result;
+  }
+  return value;
+}