@langgraph-js/pure-graph 2.10.0 → 3.0.0

package/dist/adapter/fetch/index.js

@@ -1,5 +1,5 @@
-import { s as serialiseAsDict, L as LangGraphGlobal } from '../../stream-D0YD2Pjq.js';
-import { c as createEndpoint } from '../../createEndpoint-CN_RHDEd.js';
+import { s as serialiseAsDict, a as streamState, g as getGraph, L as LangGraphGlobal } from '../../stream-umoA6h4q.js';
+import { c as createEndpoint } from '../../createEndpoint-BViLxrhh.js';
 import z from 'zod';
 import camelcaseKeys from 'camelcase-keys';
 
@@ -15,7 +15,7 @@ const AssistantConfig = z.object({
   configurable: AssistantConfigurable.optional()
 }).catchall(z.unknown()).describe("The configuration of an assistant.");
 z.object({
-  assistant_id: z.string().uuid(),
+  assistant_id: z.string(),
   graph_id: z.string(),
   config: AssistantConfig,
   created_at: z.string(),
@@ -42,23 +42,44 @@ z.object({
   offset: z.number().int().optional()
 });
 const ThreadIdParamSchema = z.object({
-  thread_id: z.string().uuid()
+  thread_id: z.string()
 });
 const RunIdParamSchema = z.object({
-  thread_id: z.string().uuid(),
-  run_id: z.string().uuid()
+  thread_id: z.string(),
+  run_id: z.string()
 });
 const AssistantsSearchSchema = z.object({
   graph_id: z.string().optional(),
   metadata: MetadataSchema.optional(),
   limit: z.number().int().optional(),
-  offset: z.number().int().optional()
+  offset: z.number().int().optional(),
+  sort_by: z.enum(["assistant_id", "graph_id", "name", "created_at", "updated_at"]).optional(),
+  sort_order: z.enum(["asc", "desc"]).optional()
+});
+const AssistantCountSchema = z.object({
+  graph_id: z.string().optional(),
+  metadata: MetadataSchema.optional()
 });
 const AssistantGraphQuerySchema = z.object({
-  xray: z.string().optional()
+  xray: z.union([z.string(), z.boolean(), z.number()]).optional()
+});
+const AssistantPatchSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  metadata: MetadataSchema.optional(),
+  config: AssistantConfig.optional()
+}).optional();
+const AssistantCreateSchema = z.object({
+  assistant_id: z.string().optional(),
+  graph_id: z.string().describe("The ID of graph to create an assistant from."),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  metadata: MetadataSchema.optional(),
+  config: AssistantConfig.optional(),
+  if_exists: z.enum(["raise", "do_nothing"]).optional()
 });
 const RunStreamPayloadSchema = z.object({
-  assistant_id: z.union([z.string().uuid(), z.string()]),
+  assistant_id: z.union([z.string(), z.string()]),
   checkpoint_id: z.string().optional(),
   input: z.any().optional(),
   command: CommandSchema.optional(),
@@ -93,11 +114,12 @@ const RunJoinStreamQuerySchema = z.object({
   stream_mode: z.enum(["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"]).optional()
 });
 const ThreadCreatePayloadSchema = z.object({
-  thread_id: z.string().uuid().describe("The ID of the thread. If not provided, an ID is generated.").optional(),
+  thread_id: z.string().describe("The ID of thread. If not provided, an ID is generated.").optional(),
   metadata: MetadataSchema.optional(),
   if_exists: z.union([z.literal("raise"), z.literal("do_nothing")]).optional()
 }).describe("Payload for creating a thread.");
 const ThreadSearchPayloadSchema = z.object({
+  ids: z.array(z.string()).describe("List of thread IDs to include. Others are excluded.").optional(),
   metadata: MetadataSchema.describe("Metadata to search for.").optional(),
   status: z.enum(["idle", "busy", "interrupted", "error"]).describe("Filter by thread status.").optional(),
   values: z.any().describe("Filter by thread values.").optional(),
@@ -105,14 +127,92 @@ const ThreadSearchPayloadSchema = z.object({
   offset: z.number().int().gte(0).describe("Offset to start from.").optional(),
   sort_by: z.enum(["thread_id", "status", "created_at", "updated_at"]).describe("Sort by field.").optional(),
   sort_order: z.enum(["asc", "desc"]).describe("Sort order.").optional(),
+  select: z.array(
+    z.enum([
+      "thread_id",
+      "created_at",
+      "updated_at",
+      "metadata",
+      "config",
+      "context",
+      "status",
+      "values",
+      "interrupts"
+    ])
+  ).describe("Specify which fields to return. If not provided, all fields are returned.").optional(),
   without_details: z.boolean().describe("Whether to return values.").optional()
 }).describe("Payload for listing threads.");
-const ThreadStateUpdate = z.object({
+z.object({
   values: z.union([z.record(z.string(), z.unknown()), z.array(z.record(z.string(), z.unknown()))]).nullish()
   // as_node: z.string().optional(),
   // checkpoint_id: z.string().optional(),
   // checkpoint: CheckpointSchema.nullish(),
 }).describe("Payload for adding state to a thread.");
+const ThreadPatchSchema = z.object({
+  metadata: MetadataSchema.optional(),
+  status: z.enum(["idle", "busy", "interrupted", "error"]).optional(),
+  values: z.any().optional()
+}).describe("Payload for patching a thread.");
+const RunCreateSchema = z.object({
+  assistant_id: z.string(),
+  input: z.any().optional(),
+  command: CommandSchema.optional(),
+  metadata: MetadataSchema.optional(),
+  config: AssistantConfig.optional(),
+  webhook: z.string().optional(),
+  interrupt_before: z.union([z.literal("*"), z.array(z.string())]).optional(),
+  interrupt_after: z.union([z.literal("*"), z.array(z.string())]).optional(),
+  on_disconnect: z.enum(["cancel", "continue"]).optional().default("continue"),
+  multitask_strategy: z.enum(["reject", "rollback", "interrupt", "enqueue"]).optional(),
+  stream_mode: z.array(z.enum(["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"])).optional(),
+  stream_subgraphs: z.boolean().optional(),
+  stream_resumable: z.boolean().optional(),
+  after_seconds: z.number().optional(),
+  if_not_exists: z.enum(["create", "reject"]).optional(),
+  on_completion: z.enum(["complete", "continue"]).optional(),
+  feedback_keys: z.array(z.string()).optional(),
+  langsmith_tracer: z.unknown().optional()
+}).describe("Payload for creating a run (background/wait).");
+const RunWaitQuerySchema = z.object({
+  cancel_on_disconnect: z.coerce.boolean().optional().default(false)
+});
+const RunJoinQuerySchema = z.object({
+  cancel_on_disconnect: z.coerce.boolean().optional().default(false)
+});
+const RunCreateStatelessSchema = z.object({
+  assistant_id: z.string().describe("The assistant ID or graph name to run."),
+  input: z.any().optional().describe("The input to the graph."),
+  command: CommandSchema.optional(),
+  metadata: MetadataSchema.optional().describe("Metadata to assign to the run."),
+  config: AssistantConfig.optional(),
+  context: z.object({}).catchall(z.any()).optional().describe("Static context added to the assistant."),
+  webhook: z.string().optional(),
+  interrupt_before: z.union([z.literal("*"), z.array(z.string())]).optional(),
+  interrupt_after: z.union([z.literal("*"), z.array(z.string())]).optional(),
+  stream_mode: z.union([
+    z.enum(["values", "messages", "messages-tuple", "tasks", "checkpoints", "updates", "events", "debug", "custom"]),
+    z.array(z.enum(["values", "messages", "messages-tuple", "tasks", "checkpoints", "updates", "events", "debug", "custom"]))
+  ]).optional().default(["values"]),
+  feedback_keys: z.array(z.string()).optional(),
+  stream_subgraphs: z.boolean().optional().default(false),
+  stream_resumable: z.boolean().optional().default(false)
+}).describe("Payload for creating a stateless run.");
+const RunBatchCreateSchema = z.array(RunCreateStatelessSchema).min(1).describe("Payload for creating a batch of stateless runs.");
+const RunsCancelQuerySchema = z.object({
+  action: z.enum(["interrupt", "rollback"]).optional().default("interrupt").describe("Action to take when cancelling the run."),
+  wait: z.coerce.boolean().optional().default(false)
+});
+const RunsCancelSchema = z.union([
+  z.object({
+    status: z.enum(["pending", "running", "all"]).describe("Filter runs by status to cancel.")
+  }),
+  z.object({
+    thread_id: z.string().describe("The ID of the thread containing runs to cancel.")
+  }),
+  z.object({
+    run_ids: z.array(z.string()).min(1).describe("List of run IDs to cancel.")
+  })
+]);
 
 function parsePathParams(url, pattern) {
   const patternParts = pattern.split("/").filter((p) => p);
@@ -305,6 +405,55 @@ async function searchAssistants(req, context) {
     return errorResponse(error);
   }
 }
+async function countAssistants(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(AssistantCountSchema, body);
+    const data = await client.assistants.count(camelcaseKeys(payload));
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getAssistant(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    const data = await client.assistants.get(assistant_id);
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function deleteAssistant(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    await client.assistants.delete(assistant_id);
+    return jsonResponse({});
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function patchAssistant(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    const body = await req.json();
+    const payload = validate(AssistantPatchSchema, body);
+    const data = await client.assistants.update(
+      assistant_id,
+      /** @ts-ignore */
+      camelcaseKeys(payload)
+    );
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
 async function getAssistantGraph(req, context) {
   try {
     const url = new URL(req.url);
@@ -320,6 +469,71 @@ async function getAssistantGraph(req, context) {
     return errorResponse(error);
   }
 }
+async function getAssistantSubgraphs(req, context) {
+  return errorResponse(
+    {
+      },
+    501
+  );
+}
+async function getAssistantSubgraphsByNamespace(req, context) {
+  return errorResponse(
+    {
+      },
+    501
+  );
+}
+async function getAssistantSchemas(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    const data = await client.assistants.getSchemas(assistant_id);
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getAssistantVersions(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    const body = await req.json();
+    const payload = validate(AssistantPatchSchema, body);
+    const data = await client.assistants.getVersions(
+      assistant_id,
+      /** @ts-ignore */
+      camelcaseKeys(payload)
+    );
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function setLatestAssistantVersion(req, context) {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/").filter((p) => p);
+    const assistant_id = pathParts[1];
+    const queryParams = parseQueryParams(req.url);
+    const version = queryParams.version ? parseInt(queryParams.version) : 1;
+    const data = await client.assistants.setLatest(assistant_id, version);
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function createAssistant(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(AssistantCreateSchema, body);
+    const data = await client.assistants.create(camelcaseKeys(payload));
+    return jsonResponse(data);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
 
 async function createThread(req, context) {
   try {
@@ -343,6 +557,16 @@ async function searchThreads(req, context) {
     return errorResponse(error);
   }
 }
+async function countThreads(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(ThreadSearchPayloadSchema.partial(), body);
+    const count = await client.threads.count(camelcaseKeys(payload));
+    return jsonResponse(count);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
 async function getThread(req, context) {
   try {
     const params = parsePathParams(req.url, "/threads/:thread_id");
@@ -353,6 +577,18 @@ async function getThread(req, context) {
     return errorResponse(error);
   }
 }
+async function patchThread(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const payload = validate(ThreadPatchSchema, body);
+    const thread = await client.threads.patch(thread_id, camelcaseKeys(payload));
+    return jsonResponse(thread);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
 async function deleteThread(req, context) {
   try {
     const params = parsePathParams(req.url, "/threads/:thread_id");
@@ -363,6 +599,107 @@ async function deleteThread(req, context) {
     return errorResponse(error);
   }
 }
+async function getThreadState(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/state");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const queryParams = parseQueryParams(req.url);
+    const options = {
+      subgraphs: queryParams.subgraphs === "true" || queryParams.subgraphs === true
+    };
+    const state = await client.threads.getState(thread_id, options);
+    return jsonResponse(state);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function updateThreadState(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/state");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const result = await client.threads.updateState(thread_id, camelcaseKeys(body));
+    return jsonResponse(result);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getThreadStateAtCheckpoint(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/state/checkpoint");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const queryParams = parseQueryParams(req.url);
+    const options = {
+      subgraphs: queryParams.subgraphs === "true" || queryParams.subgraphs === true,
+      ...body
+    };
+    const state = await client.threads.getState(thread_id, options);
+    return jsonResponse(state);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getThreadHistory(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/history");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const queryParams = parseQueryParams(req.url);
+    const options = {
+      limit: queryParams.limit ? parseInt(queryParams.limit, 10) : void 0,
+      before: queryParams.before
+    };
+    const history = await client.threads.getStateHistory(thread_id, options);
+    return jsonResponse(history);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getThreadHistoryPost(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/history");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const options = {
+      limit: body.limit,
+      before: body.before
+    };
+    const history = await client.threads.getStateHistory(thread_id, options);
+    return jsonResponse(history);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function copyThread(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/copy");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const copiedThread = await client.threads.copy(thread_id);
+    return jsonResponse(copiedThread);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function joinThreadStream(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/stream");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const queryParams = parseQueryParams(req.url);
+    const options = {
+      lastEventId: req.headers.get("Last-Event-ID") || queryParams.last_event_id,
+      streamModes: queryParams.stream_modes ? Array.isArray(queryParams.stream_modes) ? queryParams.stream_modes : [queryParams.stream_modes] : void 0
+    };
+    return new Response('data: {"status": "stream_ready"}\n\n', {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
 
 async function streamRun(req, context) {
   try {
@@ -463,14 +800,367 @@ async function cancelRun(req, context) {
     return errorResponse(error);
   }
 }
-async function updateThreadState(req, context) {
+
+async function createRun(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/runs");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const payload = validate(RunCreateSchema, body);
+    const camelPayload = camelcaseKeys(payload);
+    camelPayload.config = camelPayload.config || {};
+    camelPayload.config.configurable = camelPayload.config.configurable || {};
+    const langgraphContext = context?.langgraph_context;
+    if (langgraphContext) {
+      Object.assign(camelPayload.config.configurable, langgraphContext);
+    }
+    camelPayload.config.configurable.graph_id = payload.assistant_id;
+    camelPayload.config.configurable.thread_id = thread_id;
+    const threads = client.threads;
+    const run = await threads.createRun(thread_id, payload.assistant_id, camelPayload);
+    (async () => {
+      try {
+        for await (const _ of streamState(threads, run, camelPayload, {
+          attempt: 0,
+          getGraph
+        })) {
+        }
+      } catch (error) {
+        console.error("Background run error:", error);
+      }
+    })();
+    return jsonResponse(run, 200, {
+      "Content-Location": `/threads/${thread_id}/runs/${run.run_id}`
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function waitRun(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/runs/wait");
+    const { thread_id } = validate(ThreadIdParamSchema, params);
+    const body = await req.json();
+    const payload = validate(RunCreateSchema, body);
+    const queryParams = parseQueryParams(req.url);
+    const { cancel_on_disconnect } = validate(RunWaitQuerySchema, queryParams);
+    const camelPayload = camelcaseKeys(payload);
+    camelPayload.config = camelPayload.config || {};
+    camelPayload.config.configurable = camelPayload.config.configurable || {};
+    const langgraphContext = context?.langgraph_context;
+    if (langgraphContext) {
+      Object.assign(camelPayload.config.configurable, langgraphContext);
+    }
+    camelPayload.config.configurable.graph_id = payload.assistant_id;
+    camelPayload.config.configurable.thread_id = thread_id;
+    const threads = client.threads;
+    const run = await threads.createRun(thread_id, payload.assistant_id, camelPayload);
+    const stateValues = {};
+    for await (const { event, data } of streamState(threads, run, camelPayload, {
+      attempt: 0,
+      getGraph
+    })) {
+      if (event === "end" || event === "writes/value") {
+        if (data && typeof data === "object") {
+          Object.assign(stateValues, data);
+        }
+      }
+    }
+    return jsonResponse(stateValues, 200, {
+      "Content-Location": `/threads/${thread_id}/runs/${run.run_id}`
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getRun(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/runs/:run_id");
+    const { thread_id, run_id } = validate(RunIdParamSchema, params);
+    const runs = await client.runs.list(thread_id, { limit: 1e3 });
+    const run = runs.find((r) => r.run_id === run_id);
+    if (!run) {
+      return errorResponse(new Error("Run not found"), 404);
+    }
+    return jsonResponse(run);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function deleteRun(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/runs/:run_id");
+    const { thread_id, run_id } = validate(RunIdParamSchema, params);
+    await client.threads.updateRun(run_id, { status: "deleted" });
+    return new Response(null, { status: 204 });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function joinRun(req, context) {
+  try {
+    const params = parsePathParams(req.url, "/threads/:thread_id/runs/:run_id/join");
+    const { thread_id, run_id } = validate(RunIdParamSchema, params);
+    const queryParams = parseQueryParams(req.url);
+    const { cancel_on_disconnect } = validate(RunJoinQuerySchema, queryParams);
+    const runs = await client.runs.list(thread_id, { limit: 1e3 });
+    const run = runs.find((r) => r.run_id === run_id);
+    if (!run) {
+      return errorResponse(new Error("Run not found"), 404);
+    }
+    if (run.status === "success" || run.status === "error") {
+      return jsonResponse({});
+    }
+    const controller = new AbortController();
+    if (cancel_on_disconnect) {
+      const cleanup = () => {
+        controller.abort("Client disconnected");
+      };
+      req.signal?.addEventListener("abort", cleanup);
+    }
+    const stateValues = {};
+    for await (const { event, data } of client.runs.joinStream(thread_id, run_id, {
+      signal: controller.signal,
+      cancelOnDisconnect: cancel_on_disconnect
+    })) {
+      if (event.event === "end" || event.event === "writes/value") {
+        if (data && typeof data === "object") {
+          Object.assign(stateValues, data);
+        }
+      }
+    }
+    return jsonResponse(stateValues);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+
+async function createStatelessRun(req, context) {
   try {
-    const params = parsePathParams(req.url, "/threads/:thread_id/state");
-    const { thread_id } = validate(z.object({ thread_id: z.string().uuid() }), params);
     const body = await req.json();
-    const payload = validate(ThreadStateUpdate, body);
-    const inserted = await client.threads.updateState(thread_id, payload);
-    return jsonResponse(inserted);
+    const payload = validate(RunCreateStatelessSchema, body);
+    const camelPayload = camelcaseKeys(payload);
+    camelPayload.config = camelPayload.config || {};
+    camelPayload.config.configurable = camelPayload.config.configurable || {};
+    const langgraphContext = context?.langgraph_context;
+    if (langgraphContext) {
+      Object.assign(camelPayload.config.configurable, langgraphContext);
+    }
+    const threads = client.threads;
+    const thread = await threads.create({
+      metadata: { ...camelPayload.metadata, temporary: true }
+    });
+    camelPayload.config.configurable.graph_id = payload.assistant_id;
+    camelPayload.config.configurable.thread_id = thread.thread_id;
+    camelPayload.temporary = true;
+    const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
+    (async () => {
+      try {
+        for await (const _ of streamState(threads, run, camelPayload, {
+          attempt: 0,
+          getGraph
+        })) {
+        }
+      } catch (error) {
+        console.error("Stateless run error:", error);
+      } finally {
+        try {
+          await threads.delete(thread.thread_id);
+        } catch (e) {
+          console.error("Error cleaning up temporary thread:", e);
+        }
+      }
+    })();
+    return jsonResponse(run, 200, {
+      "Content-Location": `/threads/${thread.thread_id}/runs/${run.run_id}`
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function streamStatelessRun(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(RunCreateStatelessSchema, body);
+    const camelPayload = camelcaseKeys(payload);
+    camelPayload.config = camelPayload.config || {};
+    camelPayload.config.configurable = camelPayload.config.configurable || {};
+    const langgraphContext = context?.langgraph_context;
+    if (langgraphContext) {
+      Object.assign(camelPayload.config.configurable, langgraphContext);
+    }
+    const threads = client.threads;
+    const thread = await threads.create({
+      metadata: { ...camelPayload.metadata, temporary: true }
+    });
+    camelPayload.config.configurable.graph_id = payload.assistant_id;
+    camelPayload.config.configurable.thread_id = thread.thread_id;
+    camelPayload.temporary = true;
+    const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
+    return createSSEStream(
+      withHeartbeat(async (writer) => {
+        try {
+          for await (const event of streamState(threads, run, camelPayload, {
+            attempt: 0,
+            getGraph
+          })) {
+            await writer.writeSSE({ data: JSON.stringify(event), event: "data" });
+          }
+        } catch (error) {
+          if (error instanceof Error && error.name !== "AbortError") {
+            console.error("Stream error:", error);
+            throw error;
+          }
+        } finally {
+          try {
+            await threads.delete(thread.thread_id);
+          } catch (e) {
+            console.error("Error cleaning up temporary thread:", e);
+          }
+        }
+      })
+    );
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function waitStatelessRun(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(RunCreateStatelessSchema, body);
+    const camelPayload = camelcaseKeys(payload);
+    camelPayload.config = camelPayload.config || {};
+    camelPayload.config.configurable = camelPayload.config.configurable || {};
+    const langgraphContext = context?.langgraph_context;
+    if (langgraphContext) {
+      Object.assign(camelPayload.config.configurable, langgraphContext);
+    }
+    const threads = client.threads;
+    const thread = await threads.create({
+      metadata: { ...camelPayload.metadata, temporary: true }
+    });
+    camelPayload.config.configurable.graph_id = payload.assistant_id;
+    camelPayload.config.configurable.thread_id = thread.thread_id;
+    camelPayload.temporary = true;
+    const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
+    const stateValues = {};
+    try {
+      for await (const { event, data } of streamState(threads, run, camelPayload, {
+        attempt: 0,
+        getGraph
+      })) {
+        if (event === "end" || event === "writes/value") {
+          if (data && typeof data === "object") {
+            Object.assign(stateValues, data);
+          }
+        }
+      }
+    } finally {
+      try {
+        await threads.delete(thread.thread_id);
+      } catch (e) {
+        console.error("Error cleaning up temporary thread:", e);
+      }
+    }
+    return jsonResponse(stateValues, 200, {
+      "Content-Location": `/threads/${thread.thread_id}/runs/${run.run_id}`
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function createBatchRuns(req, context) {
+  try {
+    const body = await req.json();
+    const payloads = validate(RunBatchCreateSchema, body);
+    const threads = client.threads;
+    const results = [];
+    const runPromises = payloads.map(async (payload) => {
+      try {
+        const camelPayload = camelcaseKeys(payload);
+        camelPayload.config = camelPayload.config || {};
+        camelPayload.config.configurable = camelPayload.config.configurable || {};
+        const langgraphContext = context?.langgraph_context;
+        if (langgraphContext) {
+          Object.assign(camelPayload.config.configurable, langgraphContext);
+        }
+        const thread = await threads.create({
+          metadata: { ...camelPayload.metadata, temporary: true }
+        });
+        camelPayload.config.configurable.graph_id = payload.assistant_id;
+        camelPayload.config.configurable.thread_id = thread.thread_id;
+        camelPayload.temporary = true;
+        const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
+        (async () => {
+          try {
+            for await (const _ of streamState(threads, run, camelPayload, {
+              attempt: 0,
+              getGraph
+            })) {
+            }
+          } catch (error) {
+            console.error("Batch run error:", error);
+          } finally {
+            try {
+              await threads.delete(thread.thread_id);
+            } catch (e) {
+              console.error("Error cleaning up temporary thread:", e);
+            }
+          }
+        })();
+        return { thread_id: thread.thread_id, run_id: run.run_id };
+      } catch (error) {
+        console.error("Batch run creation error:", error);
+        return { error: (error instanceof Error ? error.message : "Unknown error") || "Unknown error" };
+      }
+    });
+    const runResults = await Promise.all(runPromises);
+    results.push(...runResults);
+    return jsonResponse(results, 200);
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function cancelRuns(req, context) {
+  try {
+    const body = await req.json();
+    const payload = validate(RunsCancelSchema, body);
+    const url = new URL(req.url);
+    const queryParams = validate(RunsCancelQuerySchema, {
+      action: url.searchParams.get("action") || "interrupt"
+    });
+    const threads = client.threads;
+    let cancelledRuns = [];
+    if ("run_ids" in payload && payload.run_ids) {
+      for (const runId of payload.run_ids) {
+        try {
+          console.warn(`Cancel by run_id ${runId} not fully implemented yet`);
+        } catch (error) {
+          console.error(`Error cancelling run ${runId}:`, error);
+        }
+      }
+    } else if ("thread_id" in payload && payload.thread_id) {
+      const threadId = payload.thread_id;
+      try {
+        const runs = await threads.listRuns(threadId, {
+          limit: 1e3,
+          offset: 0
+        });
+        for (const run of runs) {
+          try {
+            client.runs.cancel(threadId, run.run_id, queryParams.wait, queryParams.action);
+            cancelledRuns.push(run.run_id);
+          } catch (error) {
+            console.error(`Error cancelling run ${run.run_id}:`, error);
+          }
+        }
+      } catch (error) {
+        console.error(`Error listing runs for thread ${threadId}:`, error);
+      }
+    } else if ("status" in payload && payload.status) {
+      console.warn(`Cancel by status ${payload.status} not fully implemented yet`);
+    }
+    return new Response(null, { status: 204 });
   } catch (error) {
     return errorResponse(error);
   }
@@ -483,11 +1173,61 @@ const routes = [
     pattern: /^\/assistants\/search$/,
     handler: searchAssistants
   },
+  {
+    method: "POST",
+    pattern: /^\/assistants\/count$/,
+    handler: countAssistants
+  },
+  {
+    method: "GET",
+    pattern: /^\/assistants\/[^/]+$/,
+    handler: getAssistant
+  },
+  {
+    method: "DELETE",
+    pattern: /^\/assistants\/[^/]+$/,
+    handler: deleteAssistant
+  },
+  {
+    method: "PATCH",
+    pattern: /^\/assistants\/[^/]+$/,
+    handler: patchAssistant
+  },
   {
     method: "GET",
     pattern: /^\/assistants\/[^/]+\/graph$/,
     handler: getAssistantGraph
   },
+  {
+    method: "GET",
+    pattern: /^\/assistants\/[^/]+\/subgraphs$/,
+    handler: getAssistantSubgraphs
+  },
+  {
+    method: "GET",
+    pattern: /^\/assistants\/[^/]+\/subgraphs\/[^/]+$/,
+    handler: getAssistantSubgraphsByNamespace
+  },
+  {
+    method: "GET",
+    pattern: /^\/assistants\/[^/]+\/schemas$/,
+    handler: getAssistantSchemas
+  },
+  {
+    method: "POST",
+    pattern: /^\/assistants\/[^/]+\/versions$/,
+    handler: getAssistantVersions
+  },
+  {
+    method: "POST",
+    pattern: /^\/assistants\/[^/]+\/latest$/,
+    handler: setLatestAssistantVersion
+  },
+  {
+    method: "POST",
+    pattern: /^\/assistants$/,
+    handler: createAssistant
+  },
   // Threads
   {
     method: "POST",
@@ -499,41 +1239,134 @@ const routes = [
     pattern: /^\/threads\/search$/,
     handler: searchThreads
   },
+  {
+    method: "POST",
+    pattern: /^\/threads\/count$/,
+    handler: countThreads
+  },
   {
     method: "GET",
     pattern: /^\/threads\/[^/]+$/,
     handler: getThread
   },
+  {
+    method: "PATCH",
+    pattern: /^\/threads\/[^/]+$/,
+    handler: patchThread
+  },
   {
     method: "DELETE",
     pattern: /^\/threads\/[^/]+$/,
     handler: deleteThread
   },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/state$/,
+    handler: getThreadState
+  },
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/state$/,
+    handler: updateThreadState
+  },
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/state\/checkpoint$/,
+    handler: getThreadStateAtCheckpoint
+  },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/history$/,
+    handler: getThreadHistory
+  },
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/history$/,
+    handler: getThreadHistoryPost
+  },
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/copy$/,
+    handler: copyThread
+  },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/stream$/,
+    handler: joinThreadStream
+  },
   // Runs
+  // POST requests must come before GET requests with same path prefix
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/runs$/,
+    handler: createRun
+  },
   {
     method: "POST",
     pattern: /^\/threads\/[^/]+\/runs\/stream$/,
     handler: streamRun
   },
   {
-    method: "GET",
-    pattern: /^\/threads\/[^/]+\/runs\/[^/]+\/stream$/,
-    handler: joinRunStream
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/runs\/wait$/,
+    handler: waitRun
+  },
+  {
+    method: "POST",
+    pattern: /^\/threads\/[^/]+\/runs\/[^/]+\/cancel$/,
+    handler: cancelRun
   },
+  // GET requests
   {
     method: "GET",
     pattern: /^\/threads\/[^/]+\/runs$/,
     handler: listRuns
   },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/runs\/[^/]+$/,
+    handler: getRun
+  },
+  {
+    method: "DELETE",
+    pattern: /^\/threads\/[^/]+\/runs\/[^/]+$/,
+    handler: deleteRun
+  },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/runs\/[^/]+\/join$/,
+    handler: joinRun
+  },
+  {
+    method: "GET",
+    pattern: /^\/threads\/[^/]+\/runs\/[^/]+\/stream$/,
+    handler: joinRunStream
+  },
+  // Stateless Runs
   {
     method: "POST",
-    pattern: /^\/threads\/[^/]+\/runs\/[^/]+\/cancel$/,
-    handler: cancelRun
+    pattern: /^\/runs$/,
+    handler: createStatelessRun
   },
   {
     method: "POST",
-    pattern: /^\/threads\/[^/]+\/state$/,
-    handler: updateThreadState
+    pattern: /^\/runs\/stream$/,
+    handler: streamStatelessRun
+  },
+  {
+    method: "POST",
+    pattern: /^\/runs\/wait$/,
+    handler: waitStatelessRun
+  },
+  {
+    method: "POST",
+    pattern: /^\/runs\/batch$/,
+    handler: createBatchRuns
+  },
+  {
+    method: "POST",
+    pattern: /^\/runs\/cancel$/,
+    handler: cancelRuns
   }
 ];
 const replaceRequest = (req) => {
@@ -570,5 +1403,5 @@ async function handleRequest(req, context = {}) {
   }
 }
 
-export { cancelRun, createThread, deleteThread, getAssistantGraph, getThread, handleRequest, joinRunStream, listRuns, searchAssistants, searchThreads, streamRun, updateThreadState };
+export { cancelRun, cancelRuns, copyThread, countAssistants, countThreads, createAssistant, createBatchRuns, createRun, createStatelessRun, createThread, deleteAssistant, deleteRun, deleteThread, getAssistant, getAssistantGraph, getAssistantSchemas, getAssistantSubgraphs, getAssistantSubgraphsByNamespace, getAssistantVersions, getRun, getThread, getThreadHistory, getThreadHistoryPost, getThreadState, getThreadStateAtCheckpoint, handleRequest, joinRun, joinRunStream, joinThreadStream, listRuns, patchAssistant, patchThread, searchAssistants, searchThreads, setLatestAssistantVersion, streamRun, streamStatelessRun, updateThreadState, waitRun, waitStatelessRun };
 //# sourceMappingURL=index.js.map