@alexanderolsen/create-deepagent 0.1.0

package/registry/frameworks/deno/client/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/registry/frameworks/deno/client/tsconfig.node.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/registry/frameworks/deno/client/vite.config.ts

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://localhost:8000",
+        changeOrigin: true,
+      },
+    },
+  },
+  build: {
+    outDir: "../dist",
+    emptyOutDir: true,
+  },
+});

package/registry/frameworks/deno/deno.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "lib": ["deno.window", "deno.unstable"],
+    "strict": true
+  },
+  "tasks": {
+    "dev": "deno run --watch --allow-env --allow-net --allow-read --allow-sys main.ts",
+    "start": "deno run --allow-env --allow-net --allow-read --allow-sys main.ts",
+    "build:client": "cd client && pnpm install && pnpm build"
+  },
+  "nodeModulesDir": "auto",
+  "deploy": {
+    "entrypoint": "main.ts",
+    "include": ["main.ts", "server/", "dist/"]
+  }
+}

package/registry/frameworks/deno/main.ts

@@ -0,0 +1,23 @@
+/**
+ * Deno Deploy entrypoint.
+ *
+ * Serves the Agent Streaming Protocol under `/api/threads/...` and the Vite-
+ * built React SPA from `dist/` for all other routes.
+ */
+
+import { Hono } from "hono";
+import { serveStatic } from "hono/deno";
+
+import { api } from "./server/routes.ts";
+
+const app = new Hono();
+
+app.route("/api", api);
+
+app.use(serveStatic({ root: "./dist" }));
+app.get("*", serveStatic({ path: "./dist/index.html" }));
+
+const port = Number(Deno.env.get("PORT") ?? 8000);
+console.log(`Listening on http://localhost:${port}`);
+
+Deno.serve({ port }, app.fetch);

package/registry/frameworks/deno/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "js-deno",
+  "private": true,
+  "dependencies": {
+    "@langchain/core": "^1.2.1",
+    "@langchain/langgraph": "^1.3.7",
+    "@langchain/openai": "^1.4.7",
+    "@langchain/protocol": "^0.0.16",
+    "deepagents": "^1.10.2",
+    "hono": "^4.7.10",
+    "langchain": "^1.4.4",
+    "zod": "^4.4.3"
+  }
+}

package/registry/frameworks/deno/server/agent/index.ts

@@ -0,0 +1,60 @@
+import { MemorySaver } from "@langchain/langgraph";
+import { ChatOpenAI } from "@langchain/openai";
+import { createDeepAgent } from "deepagents";
+
+import { stripReasoningReplay } from "./middleware.ts";
+import { calculator, searchWeb } from "./tools.ts";
+
+const coordinatorModel = new ChatOpenAI({
+  model: "gpt-5.4-mini",
+  reasoning: { effort: "low", summary: "auto" },
+});
+
+const subagentModel = new ChatOpenAI({ model: "gpt-5.4-mini" });
+
+/**
+ * In-memory checkpointer — the single source of truth for threads.
+ *
+ * Exported so the server can enumerate threads (via `checkpointer.storage`) and
+ * delete them (`checkpointer.deleteThread`). It is process-local and volatile:
+ * restarting the server clears every thread.
+ */
+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/deno/server/agent/middleware.ts

@@ -0,0 +1,24 @@
+import { AIMessage, type BaseMessage } from "@langchain/core/messages";
+import { createMiddleware } from "langchain";
+
+/**
+ * Rebuild prior assistant messages so the Responses API doesn't replay stale
+ * item ids.
+ */
+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/deno/server/agent/tools.ts

@@ -0,0 +1,64 @@
+import { tool } from "langchain";
+import { z } from "zod";
+
+/**
+ * Mock tools used to demonstrate message and tool-call streaming.
+ *
+ * Both tools are intentionally fake so the example runs offline. What matters
+ * is that the agent (and its subagents) emit real tool-call deltas on the
+ * `messages` channel and tool results as `ToolMessage`s, which the UI renders.
+ */
+
+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.") }),
+  },
+);
+
+/** Demo-only arithmetic evaluator restricted to numbers and basic operators. */
+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/deno/server/registry.ts

@@ -0,0 +1,40 @@
+import { agent, checkpointer } from "./agent/index.ts";
+import { LocalThreadSession } from "./session.ts";
+
+/**
+ * Process-local registry for the agent and its per-thread sessions.
+ *
+ * Under Deno Deploy each isolate keeps its own in-memory registry.
+ *
+ * NOTE: This is in-memory and process-local. A serverless/multi-instance
+ * deployment needs a durable checkpointer (Postgres, SQLite, …) and a shared
+ * session/replay store. The wiring here stays the same; only the checkpointer
+ * in `server/agent/index.ts` and this store change.
+ */
+const sessions = new Map<string, LocalThreadSession>();
+
+/** 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;
+}
+
+/** Get or create the process-local session for a thread. */
+export function getSession(threadId: string): LocalThreadSession {
+  let session = sessions.get(threadId);
+  if (session == null) {
+    session = new LocalThreadSession(agent, threadId);
+    sessions.set(threadId, session);
+  }
+  return session;
+}
+
+/** Delete a thread: remove its session and its checkpointed state. */
+export async function deleteThread(threadId: string): Promise<void> {
+  sessions.delete(threadId);
+  await checkpointer.deleteThread(threadId);
+}

package/registry/frameworks/deno/server/routes.ts

@@ -0,0 +1,114 @@
+/**
+ * Agent Streaming Protocol route handlers for Hono.
+ *
+ * Mirrors the Next.js route handlers in `js-next/app/api/threads/`.
+ */
+
+import { Hono } from "hono";
+import type { Command, SubscribeParams } from "@langchain/protocol";
+
+import {
+  deleteThread,
+  getAgent,
+  getCheckpointer,
+  getSession,
+} from "./registry.ts";
+import {
+  ThreadNotFoundError,
+  getThreadHistory,
+  getThreadState,
+  listThreads,
+  updateThreadState,
+} from "./threads.ts";
+
+const SSE_HEADERS = {
+  "cache-control": "no-cache, no-transform",
+  "content-type": "text/event-stream",
+  connection: "keep-alive",
+  "x-accel-buffering": "no",
+};
+
+export const api = new Hono();
+
+api.get("/threads", async (c) => {
+  const threads = await listThreads(getAgent().graph, getCheckpointer());
+  return c.json(threads);
+});
+
+api.delete("/threads/:threadId", async (c) => {
+  await deleteThread(c.req.param("threadId"));
+  return c.body(null, 204);
+});
+
+api.post("/threads/:threadId/commands", async (c) => {
+  const threadId = c.req.param("threadId");
+  const command = (await c.req.json()) as Command;
+  const result = await getSession(threadId).handleCommand(command);
+  return c.json(result);
+});
+
+api.post("/threads/:threadId/stream", async (c) => {
+  const threadId = c.req.param("threadId");
+  const subscribeParams = (await c.req.json()) as SubscribeParams;
+  const stream = getSession(threadId).stream(subscribeParams);
+  return c.newResponse(stream, { headers: SSE_HEADERS });
+});
+
+api.get("/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;
+  }
+});
+
+api.post("/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,
+    );
+  }
+});
+
+api.post("/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;
+  }
+});

package/registry/frameworks/deno/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;
+}

package/registry/frameworks/deno/server/session.ts

@@ -0,0 +1,210 @@
+import type { ReactAgent } from "langchain";
+// `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 {
+  Command,
+  CommandResponse,
+  ErrorResponse,
+  SubscribeParams,
+} from "@langchain/protocol";
+
+import { isRecord, sanitizeForJson } from "./serialize.ts";
+
+// `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;
+}
+
+/**
+ * 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`,
+  );
+}
+
+/**
+ * Minimal in-memory Agent Streaming Protocol session for the example.
+ *
+ * This class is the server-side counterpart to `HttpAgentServerAdapter`:
+ *
+ * - `POST /threads/:thread_id/commands` sends a JSON `Command` and receives a
+ *   `CommandResponse` or `ErrorResponse`.
+ * - `POST /threads/:thread_id/stream` opens a connection-scoped SSE
+ *   subscription described by `SubscribeParams`.
+ * - Events are buffered by `seq` and replayed to later subscriptions, enabling
+ *   the SDK to rotate streams as subscriptions widen or narrow.
+ *
+ * The implementation is intentionally small and process-local. It is suitable
+ * for this example and for understanding the protocol shape, but production
+ * servers should persist threads, enforce concurrency policies, and coordinate
+ * replay buffers across workers.
+ */
+export class LocalThreadSession {
+  readonly #agent: AnyReactAgent;
+  readonly #threadId: string;
+
+  /**
+   * 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;
+
+  #activeRun:
+    | {
+        abort(reason?: unknown): void;
+      }
+    | undefined;
+
+  constructor(agent: AnyReactAgent, threadId: string) {
+    this.#agent = agent;
+    this.#threadId = threadId;
+  }
+
+  /**
+   * Handle a thread command sent to the Agent Protocol `/commands` endpoint.
+   *
+   * The SDK sends `run.start` to start or resume a graph run on the current
+   * thread. This starts the in-process v3 stream and immediately returns a
+   * success response containing a generated `run_id`, while streamed events
+   * flow asynchronously through active `/stream` subscriptions.
+   */
+  async handleCommand(
+    command: Command,
+  ): Promise<CommandResponse | ErrorResponse> {
+    if (command.method !== "run.start") {
+      return {
+        type: "error",
+        id: command.id,
+        error: "unknown_command",
+        message: `Unsupported command: ${command.method}`,
+      } as ErrorResponse;
+    }
+
+    const params = isRecord(command.params)
+      ? (command.params as { input?: unknown })
+      : {};
+    const runId = crypto.randomUUID();
+    void this.#startRun(params.input as AgentRunInput, runId);
+
+    return {
+      type: "success",
+      id: command.id,
+      result: { run_id: runId },
+    } as CommandResponse;
+  }
+
+  /**
+   * 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);
+      },
+    });
+  }
+
+  #publish(rawEvent: ProtocolEvent) {
+    const seq = this.#nextSeq;
+    this.#nextSeq += 1;
+    const event = sanitizeEvent({
+      ...rawEvent,
+      type: "event",
+      seq,
+    } as ProtocolEvent);
+    this.#log.push(event);
+  }
+
+  async #startRun(input: AgentRunInput, runId: string) {
+    this.#activeRun?.abort("Starting a new run.");
+    // 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 this.#agent.streamEvents(input, {
+      version: "v3",
+      configurable: { thread_id: this.#threadId, run_id: runId },
+    });
+    this.#activeRun = run;
+
+    try {
+      for await (const rawEvent of run) {
+        this.#publish(rawEvent as ProtocolEvent);
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      if (this.#activeRun === run) {
+        this.#activeRun = undefined;
+      }
+    }
+  }
+}