@alexanderolsen/create-deepagent 0.1.0

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

@@ -0,0 +1,35 @@
+import { getAgent } from "@/lib/server/registry";
+import { ThreadNotFoundError, getThreadHistory } from "@/lib/server/threads";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+type Params = { params: Promise<{ threadId: string }> };
+
+/** `POST /api/threads/:threadId/history` — list past checkpointed states. */
+export async function POST(request: Request, { params }: Params) {
+  const { threadId } = await params;
+  const body = (await request.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 Response.json(history);
+  } catch (error) {
+    if (error instanceof ThreadNotFoundError) {
+      return Response.json(
+        { error: "not_found", message: error.message },
+        { status: 404 },
+      );
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,13 @@
+import { deleteThread } from "@/lib/server/registry";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+type Params = { params: Promise<{ threadId: string }> };
+
+/** `DELETE /api/threads/:threadId` — drop a thread's session and checkpoints. */
+export async function DELETE(_request: Request, { params }: Params) {
+  const { threadId } = await params;
+  await deleteThread(threadId);
+  return new Response(null, { status: 204 });
+}

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

@@ -0,0 +1,51 @@
+import { getAgent } from "@/lib/server/registry";
+import {
+  ThreadNotFoundError,
+  getThreadState,
+  updateThreadState,
+} from "@/lib/server/threads";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+type Params = { params: Promise<{ threadId: string }> };
+
+/** `GET /api/threads/:threadId/state` — read checkpointed thread state. */
+export async function GET(_request: Request, { params }: Params) {
+  const { threadId } = await params;
+  try {
+    const state = await getThreadState(getAgent().graph, threadId);
+    return Response.json(state);
+  } catch (error) {
+    if (error instanceof ThreadNotFoundError) {
+      return Response.json(
+        { error: "not_found", message: error.message },
+        { status: 404 },
+      );
+    }
+    throw error;
+  }
+}
+
+/** `POST /api/threads/:threadId/state` — create or update thread state. */
+export async function POST(request: Request, { params }: Params) {
+  const { threadId } = await params;
+  const body = (await request.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 Response.json(state);
+  } catch (error) {
+    return Response.json(
+      { error: "invalid_state_update", message: String(error) },
+      { status: 422 },
+    );
+  }
+}

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

@@ -0,0 +1,30 @@
+import type { SubscribeParams } 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/stream`
+ *
+ * The request body is a connection-scoped {@link SubscribeParams} filter. The
+ * response is an SSE stream that first replays matching buffered events and then
+ * stays attached for live events from the same thread.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const { threadId } = await params;
+  const subscribeParams = (await request.json()) as SubscribeParams;
+
+  return new Response(getSession(threadId).stream(subscribeParams), {
+    headers: {
+      "cache-control": "no-cache, no-transform",
+      "content-type": "text/event-stream",
+      connection: "keep-alive",
+      // Disable proxy buffering (e.g. nginx) so SSE frames flush immediately.
+      "x-accel-buffering": "no",
+    },
+  });
+}

package/registry/frameworks/next/app/api/threads/route.ts

@@ -0,0 +1,11 @@
+import { getAgent, getCheckpointer } from "@/lib/server/registry";
+import { listThreads } from "@/lib/server/threads";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+/** `GET /api/threads` — list every thread known to the checkpointer. */
+export async function GET() {
+  const threads = await listThreads(getAgent().graph, getCheckpointer());
+  return Response.json(threads);
+}