langgraph-api 0.0.38__py3-none-any.whl → 0.0.39__py3-none-any.whl

langgraph_api/js/tests/api.test.mts

@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeEach, beforeAll } from "vitest";
-import { Client } from "@langchain/langgraph-sdk";
+import { Client, FeedbackStreamEvent } from "@langchain/langgraph-sdk";
 
 import postgres from "postgres";
 import { findLast, gatherIterator } from "./utils.mts";
@@ -12,10 +12,10 @@ import { randomUUID } from "crypto";
 
 const sql = postgres(
   process.env.POSTGRES_URI ??
-    "postgres://postgres:postgres@127.0.0.1:5433/postgres?sslmode=disable"
+    "postgres://postgres:postgres@127.0.0.1:5433/postgres?sslmode=disable",
 );
 
-const client = new Client({
+const client = new Client<any>({
   // apiUrl: process.env["LANGGRAPH_ENDPOINT"] ?? "http://localhost:9123",
   apiUrl: "http://localhost:9123",
 });
@@ -61,7 +61,7 @@ describe("assistants", () => {
 
     await client.assistants.delete(res.assistant_id);
     await expect(() => client.assistants.get(res.assistant_id)).rejects.toThrow(
-      "HTTP 404: Not Found"
+      "HTTP 404: Not Found",
     );
   });
 
@@ -130,7 +130,7 @@ describe("assistants", () => {
 
     await client.assistants.delete(res.assistant_id);
     await expect(() => client.assistants.get(res.assistant_id)).rejects.toThrow(
-      "HTTP 404: Not Found"
+      "HTTP 404: Not Found",
     );
   });
 
@@ -154,7 +154,7 @@ describe("assistants", () => {
     });
     expect(search.length).toBeGreaterThanOrEqual(1);
     expect(search.every((i) => i.assistant_id !== create.assistant_id)).toBe(
-      true
+      true,
     );
   });
 
@@ -257,7 +257,7 @@ describe("threads copy", () => {
 
     const copiedThread = await client.threads.copy(thread.thread_id);
     const copiedThreadState = await client.threads.getState(
-      copiedThread.thread_id
+      copiedThread.thread_id,
     );
 
     // check copied thread state matches expected output
@@ -338,11 +338,11 @@ describe("threads copy", () => {
 
     // test that copied thread has original as well as new values
     const copiedThreadState = await client.threads.getState<AgentState>(
-      copiedThread.thread_id
+      copiedThread.thread_id,
     );
 
     const copiedThreadStateMessages = copiedThreadState.values.messages.map(
-      (m) => m.content
+      (m) => m.content,
     );
     expect(copiedThreadStateMessages).toEqual([
       // original messages
@@ -359,7 +359,7 @@ describe("threads copy", () => {
 
     // test that the new run on the copied thread doesn't affect the original one
     const currentOriginalThreadState = await client.threads.getState(
-      thread.thread_id
+      thread.thread_id,
     );
     expect(currentOriginalThreadState).toEqual(originalThreadState);
   });
@@ -378,7 +378,7 @@ describe("threads copy", () => {
     });
 
     const history = await client.threads.getHistory<AgentState>(
-      thread.thread_id
+      thread.thread_id,
     );
     expect(history.length).toBe(5);
     expect(history[0].values.messages.length).toBe(4);
@@ -394,11 +394,11 @@ describe("threads copy", () => {
     });
 
     const fullHistory = await client.threads.getHistory<AgentState>(
-      thread.thread_id
+      thread.thread_id,
     );
     const filteredHistory = await client.threads.getHistory<AgentState>(
       thread.thread_id,
-      { metadata: runMetadata }
+      { metadata: runMetadata },
     );
 
     expect(fullHistory.length).toBe(10);
@@ -429,13 +429,13 @@ describe("threads copy", () => {
     });
 
     const copiedThreadState = await client.threads.getState<AgentState>(
-      copyThread.thread_id
+      copyThread.thread_id,
     );
     expect(copiedThreadState.values.messages[0].content).toBe("bar");
 
     // test that updating the copied thread doesn't affect the original one
     const currentOriginalThreadState = await client.threads.getState(
-      thread.thread_id
+      thread.thread_id,
     );
     expect(currentOriginalThreadState).toEqual(originalState);
   });
@@ -462,7 +462,7 @@ describe("runs", () => {
         input: { messages: [{ type: "human", content: "bar" }] },
         config: globalConfig,
         afterSeconds: 10,
-      }
+      },
     );
 
     let runs = await client.runs.list(thread.thread_id);
@@ -486,7 +486,7 @@ describe("runs", () => {
     const stream = client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: "values", config: globalConfig }
+      { input, streamMode: "values", config: globalConfig },
     );
 
     let runId: string | null = null;
@@ -523,7 +523,7 @@ describe("runs", () => {
     expect(cur.length).toBeGreaterThan(1);
   });
 
-  it.concurrent("wait error", async () => {
+  it.concurrent("wait error", { retry: 3 }, async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
     const input = {
@@ -534,13 +534,13 @@ describe("runs", () => {
       client.runs.wait(thread.thread_id, assistant.assistant_id, {
         input,
         config: { ...globalConfig, recursion_limit: 1 },
-      })
+      }),
     ).rejects.toThrowError(/GraphRecursionError/);
     const threadUpdated = await client.threads.get(thread.thread_id);
     expect(threadUpdated.status).toBe("error");
   });
 
-  it.concurrent("wait", async () => {
+  it.concurrent("wait", { retry: 3 }, async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
     const input = {
@@ -549,7 +549,7 @@ describe("runs", () => {
     const values = await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config: globalConfig }
+      { input, config: globalConfig },
     );
 
     expect(Array.isArray((values as any).messages)).toBe(true);
@@ -566,7 +566,7 @@ describe("runs", () => {
     const stream = client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: "updates", config: globalConfig }
+      { input, streamMode: "updates", config: globalConfig },
     );
 
     let runId: string | null = null;
@@ -606,18 +606,20 @@ describe("runs", () => {
     const stream = client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: "events", config: globalConfig }
+      { input, streamMode: "events", config: globalConfig },
     );
 
     const events = await gatherIterator(stream);
     expect(new Set(events.map((i) => i.event))).toEqual(
-      new Set(["metadata", "events"])
+      new Set(["metadata", "events"]),
     );
 
     expect(
       new Set(
-        events.filter((i) => i.event === "events").map((i) => i.data.event)
-      )
+        events
+          .filter((i) => i.event === "events")
+          .map((i) => (i.data as any).event),
+      ),
     ).toEqual(
       new Set([
         "on_chain_start",
@@ -625,7 +627,7 @@ describe("runs", () => {
         "on_chat_model_end",
         "on_chat_model_start",
         "on_chat_model_stream",
-      ])
+      ]),
     );
   });
 
@@ -638,7 +640,7 @@ describe("runs", () => {
     const stream = client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: "messages", config: globalConfig }
+      { input, streamMode: "messages", config: globalConfig },
     );
 
     let runId: string | null = null;
@@ -679,7 +681,7 @@ describe("runs", () => {
         "messages/metadata",
         "messages/partial",
         "messages/complete",
-      ])
+      ]),
     );
 
     expect(runId).not.toBeNull();
@@ -696,11 +698,14 @@ describe("runs", () => {
     const stream = await client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: "messages-tuple", config: globalConfig }
+      { input, streamMode: "messages-tuple", config: globalConfig },
     );
 
     const chunks = await gatherIterator(stream);
-    const runId = findLast(chunks, (i) => i.event === "metadata")?.data.run_id;
+    const runId = findLast(
+      chunks,
+      (i): i is FeedbackStreamEvent => i.event === "metadata",
+    )?.data.run_id;
     expect(runId).not.toBeNull();
 
     const messages = chunks
@@ -730,7 +735,7 @@ describe("runs", () => {
     const stream = await client.runs.stream(
       thread.thread_id,
       assistant.assistant_id,
-      { input, streamMode: ["messages", "values"], config: globalConfig }
+      { input, streamMode: ["messages", "values"], config: globalConfig },
     );
 
     const chunks = await gatherIterator(stream);
@@ -739,7 +744,7 @@ describe("runs", () => {
 
     const messages: BaseMessage[] = findLast(
       chunks,
-      (i) => i.event === "values"
+      (i) => i.event === "values",
     )?.data.messages;
 
     expect(messages.length).toBe(4);
@@ -756,10 +761,10 @@ describe("runs", () => {
         "messages/partial",
         "messages/complete",
         "values",
-      ])
+      ]),
     );
 
-    const run = await client.runs.get(thread.thread_id, runId);
+    const run = await client.runs.get(thread.thread_id, runId!);
     expect(run.status).toBe("success");
   });
 
@@ -781,7 +786,7 @@ describe("runs", () => {
           input,
           interruptBefore: ["tool"],
           config: globalConfig,
-        })
+        }),
       );
 
       expect(chunks.filter((i) => i.event === "error").length).toBe(0);
@@ -801,7 +806,7 @@ describe("runs", () => {
         client.runs.stream(thread.thread_id, assistant.assistant_id, {
           input: null,
           config: globalConfig,
-        })
+        }),
       );
 
       expect(chunks.filter((i) => i.event === "error").length).toBe(0);
@@ -813,7 +818,7 @@ describe("runs", () => {
 
       const threadAfterContinue = await client.threads.get(thread.thread_id);
       expect(threadAfterContinue.status).toBe("idle");
-    }
+    },
   );
 
   it.concurrent("human in the loop - modification", async () => {
@@ -831,7 +836,7 @@ describe("runs", () => {
         input,
         interruptBefore: ["tool"],
         config: globalConfig,
-      })
+      }),
     );
 
     expect(chunks.filter((i) => i.event === "error").length).toBe(0);
@@ -839,7 +844,7 @@ describe("runs", () => {
     // edit the last message
     const lastMessage = findLast(
       chunks,
-      (i) => i.event === "values"
+      (i) => i.event === "values",
     )?.data.messages.at(-1);
     lastMessage.content = "modified";
 
@@ -856,7 +861,7 @@ describe("runs", () => {
     expect(modifiedThread.metadata?.modified).toBe(true);
 
     const stateAfterModify = await client.threads.getState<AgentState>(
-      thread.thread_id
+      thread.thread_id,
     );
     expect(stateAfterModify.values.messages.at(-1)?.content).toBe("modified");
     expect(stateAfterModify.next).toEqual(["tool"]);
@@ -869,7 +874,7 @@ describe("runs", () => {
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         input: null,
         config: globalConfig,
-      })
+      }),
     );
 
     const threadAfterContinue = await client.threads.get(thread.thread_id);
@@ -884,7 +889,7 @@ describe("runs", () => {
 
     // get the history
     const history = await client.threads.getHistory<AgentState>(
-      thread.thread_id
+      thread.thread_id,
     );
     expect(history.length).toBe(6);
     expect(history[0].next.length).toBe(0);
@@ -892,7 +897,7 @@ describe("runs", () => {
     expect(history.at(-1)?.next).toEqual(["__start__"]);
   });
 
-  it.concurrent("interrupt before", async () => {
+  it.concurrent("interrupt before", { retry: 3 }, async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     let thread = await client.threads.create();
     const input = {
@@ -930,7 +935,7 @@ describe("shared state", () => {
     const res1 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config }
+      { input, config },
     )) as Awaited<Record<string, any>>;
     expect(res1.sharedStateValue).toBe(null);
 
@@ -938,7 +943,7 @@ describe("shared state", () => {
     const res2 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config }
+      { input, config },
     )) as Awaited<Record<string, any>>;
     expect(res2.sharedStateValue).toBe(config.configurable.user_id);
   });
@@ -956,7 +961,7 @@ describe("shared state", () => {
     const res1 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config: config1 }
+      { input, config: config1 },
     )) as Awaited<Record<string, any>>;
 
     // Run with the same thread id but a new config
@@ -964,7 +969,7 @@ describe("shared state", () => {
     const res2 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config: config2 }
+      { input, config: config2 },
     )) as Awaited<Record<string, any>>;
 
     expect(res1.sharedStateValue).toBe(config1.configurable.user_id);
@@ -990,12 +995,12 @@ describe("shared state", () => {
     const res1 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config }
+      { input, config },
     )) as Awaited<Record<string, any>>;
     expect(res1.sharedStateFromStoreConfig).toBeDefined();
     expect(res1.sharedStateFromStoreConfig.id).toBeDefined();
     expect(res1.sharedStateFromStoreConfig.id).toBe(
-      config.configurable.user_id
+      config.configurable.user_id,
     );
   });
 
@@ -1020,12 +1025,12 @@ describe("shared state", () => {
     const res1 = (await client.runs.wait(
       thread.thread_id,
       assistant.assistant_id,
-      { input, config }
+      { input, config },
     )) as Awaited<Record<string, any>>;
     expect(res1.sharedStateFromStoreConfig).toBeDefined();
     expect(res1.sharedStateFromStoreConfig.id).toBeDefined();
     expect(res1.sharedStateFromStoreConfig.id).toBe(
-      config.configurable.user_id
+      config.configurable.user_id,
     );
 
     // Fetch data from store client
@@ -1117,10 +1122,10 @@ describe("StoreClient", () => {
     expect(searchResAfterPut.items[0].createdAt).toBeDefined();
     expect(searchResAfterPut.items[0].updatedAt).toBeDefined();
     expect(
-      new Date(searchResAfterPut.items[0].createdAt).getTime()
+      new Date(searchResAfterPut.items[0].createdAt).getTime(),
     ).toBeLessThanOrEqual(Date.now());
     expect(
-      new Date(searchResAfterPut.items[0].updatedAt).getTime()
+      new Date(searchResAfterPut.items[0].updatedAt).getTime(),
     ).toBeLessThanOrEqual(Date.now());
 
     const updatedValue = { foo: "baz" };
@@ -1137,7 +1142,7 @@ describe("StoreClient", () => {
     expect(searchResAfterUpdate.items[0].value).toEqual(updatedValue);
 
     expect(
-      new Date(searchResAfterUpdate.items[0].updatedAt).getTime()
+      new Date(searchResAfterUpdate.items[0].updatedAt).getTime(),
     ).toBeGreaterThan(new Date(searchResAfterPut.items[0].updatedAt).getTime());
 
     const listResAfterPut = await client.store.listNamespaces();
@@ -1161,12 +1166,12 @@ describe("subgraphs", () => {
     const assistant = await client.assistants.create({ graphId: "nested" });
 
     expect(
-      Object.keys(await client.assistants.getSubgraphs(assistant.assistant_id))
+      Object.keys(await client.assistants.getSubgraphs(assistant.assistant_id)),
     ).toEqual(["gp_two"]);
 
     const subgraphs = await client.assistants.getSubgraphs(
       assistant.assistant_id,
-      { recurse: true }
+      { recurse: true },
     );
 
     expect(Object.keys(subgraphs)).toEqual(["gp_two", "gp_two|p_two"]);
@@ -1201,19 +1206,17 @@ describe("subgraphs", () => {
   // (1) interrupt and then continue running, no modification
   it.concurrent("human in the loop - no modification", async () => {
     const assistant = await client.assistants.create({ graphId: "weather" });
-
     const thread = await client.threads.create();
-    const input = {
-      messages: [{ role: "human", content: "SF", id: "initial-message" }],
-    };
 
     // run until the interrupt
     let lastMessageBeforeInterrupt: { content?: string } | null = null;
     let chunks = await gatherIterator(
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
-        input,
+        input: {
+          messages: [{ role: "human", content: "SF", id: "initial-message" }],
+        },
         interruptBefore: ["tool"],
-      })
+      }),
     );
 
     for (const chunk of chunks) {
@@ -1223,16 +1226,13 @@ describe("subgraphs", () => {
       }
 
       if (chunk.event === "error") {
-        throw new Error(chunk.data);
+        throw new Error(chunk.data.error);
       }
     }
 
     expect(lastMessageBeforeInterrupt?.content).toBe("SF");
     expect(chunks).toEqual([
-      {
-        event: "metadata",
-        data: { run_id: expect.any(String), attempt: 1 },
-      },
+      { event: "metadata", data: { run_id: expect.any(String), attempt: 1 } },
       {
         event: "values",
         data: {
@@ -1285,7 +1285,7 @@ describe("subgraphs", () => {
     const stateRecursive = await client.threads.getState(
       thread.thread_id,
       undefined,
-      { subgraphs: true }
+      { subgraphs: true },
     );
 
     expect(stateRecursive.next).toEqual(["weather_graph"]);
@@ -1338,24 +1338,27 @@ describe("subgraphs", () => {
     expect(threadAfterInterrupt.status).toBe("interrupted");
 
     // continue after interrupt
-    chunks = await gatherIterator(
+    const chunksSubgraph = await gatherIterator(
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         input: null,
         streamMode: ["values", "updates"],
         streamSubgraphs: true,
-      })
+      }),
     );
 
-    expect(chunks.filter((i) => i.event === "error")).toEqual([]);
-    expect(chunks.at(-1)?.event).toBe("values");
+    expect(chunksSubgraph.filter((i) => i.event === "error")).toEqual([]);
+    expect(chunksSubgraph.at(-1)?.event).toBe("values");
 
-    const continueMessages = findLast(chunks, (i) => i.event === "values")?.data
-      .messages;
+    type ChunkType = (typeof chunksSubgraph)[number];
+    const continueMessages = findLast(
+      chunksSubgraph,
+      (i): i is ChunkType & { event: "values" } => i.event === "values",
+    )?.data.messages;
 
     expect(continueMessages.length).toBe(2);
     expect(continueMessages[0].content).toBe("SF");
     expect(continueMessages[1].content).toBe("It's sunny in San Francisco!");
-    expect(chunks).toEqual([
+    expect(chunksSubgraph).toEqual([
       {
         event: "metadata",
         data: { run_id: expect.any(String), attempt: 1 },
@@ -1497,7 +1500,7 @@ describe("subgraphs", () => {
 
     // run until the interrupt (same as before)
     let chunks = await gatherIterator(
-      client.runs.stream(thread.thread_id, assistant.assistant_id, { input })
+      client.runs.stream(thread.thread_id, assistant.assistant_id, { input }),
     );
     expect(chunks.filter((i) => i.event === "error")).toEqual([]);
 
@@ -1529,7 +1532,7 @@ describe("subgraphs", () => {
     // get inner state after update
     const innerState = await client.threads.getState<{ city: string }>(
       thread.thread_id,
-      state.tasks[0].checkpoint ?? undefined
+      state.tasks[0].checkpoint ?? undefined,
     );
 
     expect(innerState.values.city).toBe("LA");
@@ -1551,7 +1554,7 @@ describe("subgraphs", () => {
     chunks = await gatherIterator(
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         input: null,
-      })
+      }),
     );
 
     expect(chunks.filter((i) => i.event === "error")).toEqual([]);
@@ -1586,7 +1589,7 @@ describe("subgraphs", () => {
     expect(innerHistory[innerHistory.length - 1].next).toEqual(["__start__"]);
   });
 
-  it.concurrent("interrupt inside node", async () => {
+  it.concurrent("interrupt inside node", { retry: 3 }, async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
 
     let thread = await client.threads.create();
@@ -1636,7 +1639,7 @@ describe("subgraphs", () => {
     const stream = await gatherIterator(
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         command: { resume: "i want to resume" },
-      })
+      }),
     );
 
     expect(stream.at(-1)?.event).toBe("values");
@@ -1653,7 +1656,7 @@ describe("errors", () => {
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         input: { messages: [] },
         streamMode: ["debug", "events"],
-      })
+      }),
     );
 
     expect(stream.at(-1)).toMatchObject({
@@ -1672,7 +1675,7 @@ describe("errors", () => {
     const run = await client.runs.create(
       thread.thread_id,
       assistant.assistant_id,
-      { input: { messages: [] } }
+      { input: { messages: [] } },
     );
 
     await client.runs.join(thread.thread_id, run.run_id);
@@ -1687,11 +1690,11 @@ describe("errors", () => {
     const run = await client.runs.create(
       thread.thread_id,
       assistant.assistant_id,
-      { input: { messages: [] } }
+      { input: { messages: [] } },
     );
 
     const stream = await gatherIterator(
-      client.runs.joinStream(thread.thread_id, run.run_id)
+      client.runs.joinStream(thread.thread_id, run.run_id),
     );
 
     expect(stream.at(-1)).toMatchObject({
@@ -1721,7 +1724,7 @@ describe("long running tasks", () => {
         {
           input: { messages: [], delay },
           config: globalConfig,
-        }
+        },
       );
 
       await client.runs.join(thread.thread_id, run.run_id);
@@ -1737,14 +1740,12 @@ describe("long running tasks", () => {
       expect(runResult.values.messages).toMatchObject([
         { content: `finished after ${delay}ms` },
       ]);
-    }
+    },
   );
 });
 
 it("unusual newline termination characters", async () => {
-  const thread = await client.threads.create({
-    metadata: { graph_id: "agent" },
-  });
+  const thread = await client.threads.create({ graphId: "agent" });
 
   await client.threads.updateState(thread.thread_id, {
     values: {
@@ -1764,7 +1765,7 @@ it("unusual newline termination characters", async () => {
   expect(history.length).toBe(1);
   expect(history[0].values.messages.length).toBe(1);
   expect(history[0].values.messages[0].content).toBe(
-    "Page break characters: \n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029"
+    "Page break characters: \n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029",
   );
 });
 
@@ -1785,7 +1786,7 @@ describe.skip("command update state", () => {
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         command: { update: { keyOne: "value3", keyTwo: "value4" } },
         config: globalConfig,
-      })
+      }),
     );
     expect(stream.filter((chunk) => chunk.event === "error")).toEqual([]);
 
@@ -1813,7 +1814,7 @@ describe.skip("command update state", () => {
           ],
         },
         config: globalConfig,
-      })
+      }),
     );
 
     expect(stream.filter((chunk) => chunk.event === "error")).toEqual([]);
@@ -1829,3 +1830,73 @@ describe.skip("command update state", () => {
     });
   });
 });
+
+it("dynamic graph", async () => {
+  const defaultAssistant = await client.assistants.create({
+    graphId: "dynamic",
+  });
+
+  let updates = await gatherIterator(
+    client.runs.stream(null, defaultAssistant.assistant_id, {
+      input: { messages: ["input"] },
+      streamMode: ["updates"],
+    }),
+  );
+
+  expect
+    .soft(
+      updates
+        .filter((i) => i.event === "updates")
+        .flatMap((i) => Object.keys(i.data)),
+    )
+    .toEqual(expect.arrayContaining(["default"]));
+
+  updates = await gatherIterator(
+    client.runs.stream(null, defaultAssistant.assistant_id, {
+      input: { messages: ["input"] },
+      config: { configurable: { nodeName: "runtime" } },
+      streamMode: ["updates"],
+    }),
+  );
+
+  expect
+    .soft(
+      updates
+        .filter((i) => i.event === "updates")
+        .flatMap((i) => Object.keys(i.data)),
+    )
+    .toEqual(expect.arrayContaining(["runtime"]));
+
+  const configAssistant = await client.assistants.create({
+    graphId: "dynamic",
+    config: { configurable: { nodeName: "assistant" } },
+  });
+
+  let thread = await client.threads.create({ graphId: "dynamic" });
+  updates = await gatherIterator(
+    client.runs.stream(thread.thread_id, configAssistant.assistant_id, {
+      input: { messages: ["input"], configurable: { nodeName: "assistant" } },
+      streamMode: ["updates"],
+    }),
+  );
+
+  expect
+    .soft(
+      updates
+        .filter((i) => i.event === "updates")
+        .flatMap((i) => Object.keys(i.data)),
+    )
+    .toEqual(expect.arrayContaining(["assistant"]));
+
+  thread = await client.threads.get(thread.thread_id);
+
+  // check if we are properly recreating the graph with the
+  // stored configuration inside a thread
+  await client.threads.updateState(thread.thread_id, {
+    values: { messages: "update" },
+    asNode: "assistant",
+  });
+
+  const state = await client.threads.getState(thread.thread_id);
+  expect(state.values.messages).toEqual(["input", "assistant", "update"]);
+});