@langchain/langgraph-api 1.1.10 → 1.1.12

package/dist/api/assistants.mjs

@@ -86,7 +86,8 @@ api.get("/assistants/:assistant_id", async (c) => {
 api.delete("/assistants/:assistant_id", async (c) => {
     // Delete Assistant
     const assistantId = getAssistantId(c.req.param("assistant_id"));
-    return c.json(await assistants().delete(assistantId, c.var.auth));
+    const deleteThreads = c.req.query("delete_threads") === "true";
+    return c.json(await assistants().delete(assistantId, deleteThreads, c.var.auth));
 });
 api.patch("/assistants/:assistant_id", zValidator("json", schemas.AssistantPatch), async (c) => {
     // Patch Assistant

package/dist/graph/parser/index.d.mts

@@ -19,5 +19,17 @@ export declare function getStaticGraphSchema(specMap: Record<string, GraphSpec>,
     mainThread?: boolean;
     timeoutMs?: number;
 }): Promise<Record<string, GraphSchemaWithSubgraphs>>;
+/**
+ * Extract JSON schemas from a compiled graph at runtime.
+ *
+ * Uses a multi-tier extraction strategy:
+ * 1. StateSchema - Native JSON schema via getJsonSchema() (handles jsonSchemaExtra)
+ * 2. Zod Registry - Via schemaMetaRegistry (handles withLangGraph jsonSchemaExtra)
+ * 3. Direct Zod - Fallback conversion without registry (no jsonSchemaExtra)
+ * 4. Returns undefined to fall back to static TypeScript parser
+ *
+ * @param graph - The compiled Pregel graph to extract schemas from
+ * @returns GraphSchema with state/input/output/config schemas, or undefined if extraction fails
+ */
 export declare function getRuntimeGraphSchema(graph: Pregel<any, any, any, any, any>): Promise<GraphSchema | undefined>;
 export {};

package/dist/graph/parser/index.mjs

@@ -38,7 +38,66 @@ export async function getStaticGraphSchema(input, options) {
     }
     return Object.fromEntries(Object.keys(input).map((graphId, idx) => [graphId, results[idx]]));
 }
-export async function getRuntimeGraphSchema(graph) {
+// Symbol used when input inherits from state schema but as partial
+const PartialStateSchema = Symbol.for("langgraph.state.partial");
+function isStateSchemaLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getJsonSchema" in value &&
+        typeof value.getJsonSchema === "function" &&
+        "getInputJsonSchema" in value &&
+        typeof value.getInputJsonSchema === "function");
+}
+/**
+ * Try to extract schema from StateSchema instance.
+ * StateSchema handles jsonSchemaExtra internally via ReducedValue.jsonSchemaExtra
+ *
+ * @param graph - The compiled graph to extract schemas from
+ * @returns GraphSchema if StateSchema instances found, undefined otherwise
+ */
+async function tryStateSchemaExtraction(graph) {
+    const builder = graph.builder;
+    if (!builder)
+        return undefined;
+    // Check if ANY of the schemas are StateSchema-like (have getJsonSchema/getInputJsonSchema methods)
+    const schemaDefIsLike = isStateSchemaLike(builder._schemaRuntimeDefinition);
+    const inputDefIsLike = isStateSchemaLike(builder._inputRuntimeDefinition);
+    const outputDefIsLike = isStateSchemaLike(builder._outputRuntimeDefinition);
+    const hasStateSchema = schemaDefIsLike || inputDefIsLike || outputDefIsLike;
+    if (!hasStateSchema)
+        return undefined;
+    // Extract from StateSchema-like instances
+    const state = isStateSchemaLike(builder._schemaRuntimeDefinition)
+        ? builder._schemaRuntimeDefinition.getJsonSchema()
+        : undefined;
+    const input = (() => {
+        if (isStateSchemaLike(builder._inputRuntimeDefinition)) {
+            return builder._inputRuntimeDefinition.getInputJsonSchema();
+        }
+        // PartialStateSchema means input inherits from state as partial
+        if (builder._inputRuntimeDefinition === PartialStateSchema &&
+            isStateSchemaLike(builder._schemaRuntimeDefinition)) {
+            return builder._schemaRuntimeDefinition.getInputJsonSchema();
+        }
+        return undefined;
+    })();
+    const output = isStateSchemaLike(builder._outputRuntimeDefinition)
+        ? builder._outputRuntimeDefinition.getJsonSchema()
+        : undefined;
+    // StateSchema doesn't have config schema support yet
+    const config = undefined;
+    if (!state && !input && !output)
+        return undefined;
+    return { state, input, output, config };
+}
+/**
+ * Try existing Zod extraction via schemaMetaRegistry.
+ * This handles jsonSchemaExtra from withLangGraph() calls.
+ *
+ * @param graph - The compiled graph to extract schemas from
+ * @returns GraphSchema if Zod schemas found in registry, undefined otherwise
+ */
+async function tryZodRegistryExtraction(graph) {
     try {
         const { getInputTypeSchema, getOutputTypeSchema, getUpdateTypeSchema, getConfigTypeSchema, } = await import("@langchain/langgraph/zod/schema");
         const result = {
@@ -52,7 +111,78 @@ export async function getRuntimeGraphSchema(graph) {
         return result;
     }
     catch {
-        // ignore
+        return undefined;
+    }
+}
+/**
+ * Fallback: Try direct Zod conversion without registry.
+ * Handles Zod schemas that weren't registered with withLangGraph().
+ * Note: jsonSchemaExtra will NOT be included in this path.
+ *
+ * @param graph - The compiled graph to extract schemas from
+ * @returns GraphSchema if Zod schemas found, undefined otherwise
+ */
+async function tryDirectZodExtraction(graph) {
+    try {
+        const { toJsonSchema } = await import("@langchain/core/utils/json_schema");
+        const { isZodSchemaV3, isZodSchemaV4 } = await import("@langchain/core/utils/types");
+        const builder = graph.builder;
+        if (!builder)
+            return undefined;
+        const extractSchema = (schema) => {
+            if (!schema)
+                return undefined;
+            if (isZodSchemaV4(schema) || isZodSchemaV3(schema)) {
+                try {
+                    return toJsonSchema(schema);
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        };
+        const state = extractSchema(builder._schemaRuntimeDefinition);
+        const input = extractSchema(builder._inputRuntimeDefinition) ??
+            (state ? { ...state, required: undefined } : undefined);
+        const output = extractSchema(builder._outputRuntimeDefinition);
+        const config = extractSchema(builder._configRuntimeSchema);
+        if (!state && !input && !output && !config)
+            return undefined;
+        return { state, input, output, config };
+    }
+    catch {
+        return undefined;
     }
+}
+/**
+ * Extract JSON schemas from a compiled graph at runtime.
+ *
+ * Uses a multi-tier extraction strategy:
+ * 1. StateSchema - Native JSON schema via getJsonSchema() (handles jsonSchemaExtra)
+ * 2. Zod Registry - Via schemaMetaRegistry (handles withLangGraph jsonSchemaExtra)
+ * 3. Direct Zod - Fallback conversion without registry (no jsonSchemaExtra)
+ * 4. Returns undefined to fall back to static TypeScript parser
+ *
+ * @param graph - The compiled Pregel graph to extract schemas from
+ * @returns GraphSchema with state/input/output/config schemas, or undefined if extraction fails
+ */
+export async function getRuntimeGraphSchema(graph) {
+    const builder = graph.builder;
+    if (!builder)
+        return undefined;
+    // Priority 1: StateSchema (handles jsonSchemaExtra via ReducedValue)
+    const stateSchemaResult = await tryStateSchemaExtraction(graph);
+    if (stateSchemaResult)
+        return stateSchemaResult;
+    // Priority 2: Zod via schemaMetaRegistry (handles jsonSchemaExtra from withLangGraph)
+    const zodRegistryResult = await tryZodRegistryExtraction(graph);
+    if (zodRegistryResult)
+        return zodRegistryResult;
+    // Priority 3: Direct Zod conversion (no jsonSchemaExtra, but better than nothing)
+    const directZodResult = await tryDirectZodExtraction(graph);
+    if (directZodResult)
+        return directZodResult;
+    // Priority 4: Fall through to static TypeScript parser
     return undefined;
 }

package/dist/storage/ops.d.mts

@@ -77,7 +77,7 @@ export declare class FileSystemAssistants implements AssistantsRepo {
         name?: string;
         description?: string;
     }, auth: AuthContext | undefined): Promise<Assistant>;
-    delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
+    delete(assistant_id: string, delete_threads: boolean, auth: AuthContext | undefined): Promise<string[]>;
     setLatest(assistant_id: string, version: number, auth: AuthContext | undefined): Promise<Assistant>;
     getVersions(assistant_id: string, options: {
         limit: number;

package/dist/storage/ops.mjs

@@ -330,7 +330,7 @@ export class FileSystemAssistants {
             return assistant;
         });
     }
-    async delete(assistant_id, auth) {
+    async delete(assistant_id, delete_threads, auth) {
         const [filters] = await handleAuthEvent(auth, "assistants:delete", {
             assistant_id,
         });
@@ -343,13 +343,20 @@ export class FileSystemAssistants {
                 throw new HTTPException(404, { message: "Assistant not found" });
             }
             delete STORE.assistants[assistant_id];
-            // Cascade delete for assistant versions and crons
+            // Cascade delete for assistant versions and crons and threads
             STORE.assistant_versions = STORE.assistant_versions.filter((v) => v["assistant_id"] !== assistant_id);
             for (const run of Object.values(STORE.runs)) {
                 if (run["assistant_id"] === assistant_id) {
                     delete STORE.runs[run["run_id"]];
                 }
             }
+            if (delete_threads === true) {
+                for (const thread of Object.values(STORE.threads)) {
+                    if (thread["metadata"]?.["assistant_id"] === assistant_id) {
+                        delete STORE.threads[thread["thread_id"]];
+                    }
+                }
+            }
             return [assistant.assistant_id];
         });
     }

package/dist/storage/types.d.mts

@@ -274,7 +274,7 @@ export interface AssistantsRepo {
         name?: string;
         description?: string;
     }, auth: AuthContext | undefined): Promise<Assistant>;
-    delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
+    delete(assistant_id: string, delete_threads: boolean, auth: AuthContext | undefined): Promise<string[]>;
     count(options: {
         graph_id?: string;
         name?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -70,7 +70,7 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "zod": "^3.25.76 || ^4",
-    "@langchain/langgraph-ui": "1.1.10"
+    "@langchain/langgraph-ui": "1.1.12"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.59 || ^1.0.1",
@@ -98,9 +98,9 @@
     "typescript": "^4.9.5 || ^5.4.5",
     "vitest": "^3.2.4",
     "wait-port": "^1.1.0",
-    "@langchain/langgraph": "1.0.14",
+    "@langchain/langgraph": "1.1.3",
     "@langchain/langgraph-checkpoint": "1.0.0",
-    "@langchain/langgraph-sdk": "1.4.6"
+    "@langchain/langgraph-sdk": "1.5.6"
   },
   "scripts": {
     "clean": "rm -rf dist/ .turbo/ ./tests/graphs/.langgraph_api/",