langgraph-api 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

langgraph_api/js/tests/api.test.mts

@@ -15,10 +15,8 @@ const sql = postgres(
     "postgres://postgres:postgres@127.0.0.1:5433/postgres?sslmode=disable",
 );
 
-const client = new Client<any>({
-  // apiUrl: process.env["LANGGRAPH_ENDPOINT"] ?? "http://localhost:9123",
-  apiUrl: "http://localhost:9123",
-});
+const API_URL = "http://localhost:9123";
+const client = new Client<any>({ apiUrl: API_URL });
 
 // Passed to all invocation requests as the graph now requires this field to be present
 // in `configurable` due to a new `SharedValue` field requiring it.
@@ -821,7 +819,7 @@ describe("runs", () => {
     },
   );
 
-  it.concurrent("human in the loop - modification", {retry: 3}, async () => {
+  it.concurrent("human in the loop - modification", { retry: 3 }, async () => {
     // (2) interrupt, modify the message and then continue running
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
@@ -1204,103 +1202,55 @@ describe("subgraphs", () => {
   });
 
   // (1) interrupt and then continue running, no modification
-  it.concurrent("human in the loop - no modification", {retry: 3}, async () => {
-    const assistant = await client.assistants.create({ graphId: "weather" });
-    const thread = await client.threads.create();
+  it.concurrent(
+    "human in the loop - no modification",
+    { retry: 3 },
+    async () => {
+      const assistant = await client.assistants.create({ graphId: "weather" });
+      const thread = await client.threads.create();
 
-    // run until the interrupt
-    let lastMessageBeforeInterrupt: { content?: string } | null = null;
-    let chunks = await gatherIterator(
-      client.runs.stream(thread.thread_id, assistant.assistant_id, {
-        input: {
-          messages: [{ role: "human", content: "SF", id: "initial-message" }],
-        },
-        interruptBefore: ["tool"],
-      }),
-    );
+      // run until the interrupt
+      let lastMessageBeforeInterrupt: { content?: string } | null = null;
+      let chunks = await gatherIterator(
+        client.runs.stream(thread.thread_id, assistant.assistant_id, {
+          input: {
+            messages: [{ role: "human", content: "SF", id: "initial-message" }],
+          },
+          interruptBefore: ["tool"],
+        }),
+      );
 
-    for (const chunk of chunks) {
-      if (chunk.event === "values") {
-        lastMessageBeforeInterrupt =
-          chunk.data.messages[chunk.data.messages.length - 1];
-      }
+      for (const chunk of chunks) {
+        if (chunk.event === "values") {
+          lastMessageBeforeInterrupt =
+            chunk.data.messages[chunk.data.messages.length - 1];
+        }
 
-      if (chunk.event === "error") {
-        throw new Error(chunk.data.error);
+        if (chunk.event === "error") {
+          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: "values",
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
-            },
-          ],
-        },
-      },
-      {
-        event: "values",
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
-            },
-          ],
-          route: "weather",
-        },
-      },
-    ]);
-
-    let state = await client.threads.getState(thread.thread_id);
-    expect(state.next).toEqual(["weather_graph"]);
-    expect(state.tasks).toEqual([
-      {
-        id: expect.any(String),
-        name: "weather_graph",
-        path: ["__pregel_pull", "weather_graph"],
-        error: null,
-        interrupts: [],
-        checkpoint: {
-          checkpoint_ns: expect.stringMatching(/^weather_graph:/),
-          thread_id: expect.any(String),
+      expect(lastMessageBeforeInterrupt?.content).toBe("SF");
+      expect(chunks).toEqual([
+        { event: "metadata", data: { run_id: expect.any(String), attempt: 1 } },
+        {
+          event: "values",
+          data: {
+            messages: [
+              {
+                content: "SF",
+                additional_kwargs: {},
+                response_metadata: {},
+                type: "human",
+                id: "initial-message",
+              },
+            ],
+          },
         },
-        state: null,
-        result: null,
-      },
-    ]);
-
-    const stateRecursive = await client.threads.getState(
-      thread.thread_id,
-      undefined,
-      { subgraphs: true },
-    );
-
-    expect(stateRecursive.next).toEqual(["weather_graph"]);
-    expect(stateRecursive.tasks).toEqual([
-      {
-        id: expect.any(String),
-        name: "weather_graph",
-        path: ["__pregel_pull", "weather_graph"],
-        error: null,
-        interrupts: [],
-        checkpoint: null,
-        result: null,
-        state: {
-          values: {
-            city: "San Francisco",
+        {
+          event: "values",
+          data: {
             messages: [
               {
                 content: "SF",
@@ -1310,94 +1260,169 @@ describe("subgraphs", () => {
                 id: "initial-message",
               },
             ],
+            route: "weather",
           },
-          next: ["weather_node"],
-          tasks: [
-            {
-              id: expect.any(String),
-              name: "weather_node",
-              path: ["__pregel_pull", "weather_node"],
-              error: null,
-              interrupts: [],
-              checkpoint: null,
-              state: null,
-              result: null,
+        },
+      ]);
+
+      let state = await client.threads.getState(thread.thread_id);
+      expect(state.next).toEqual(["weather_graph"]);
+      expect(state.tasks).toEqual([
+        {
+          id: expect.any(String),
+          name: "weather_graph",
+          path: ["__pregel_pull", "weather_graph"],
+          error: null,
+          interrupts: [],
+          checkpoint: {
+            checkpoint_ns: expect.stringMatching(/^weather_graph:/),
+            thread_id: expect.any(String),
+          },
+          state: null,
+          result: null,
+        },
+      ]);
+
+      const stateRecursive = await client.threads.getState(
+        thread.thread_id,
+        undefined,
+        { subgraphs: true },
+      );
+
+      expect(stateRecursive.next).toEqual(["weather_graph"]);
+      expect(stateRecursive.tasks).toEqual([
+        {
+          id: expect.any(String),
+          name: "weather_graph",
+          path: ["__pregel_pull", "weather_graph"],
+          error: null,
+          interrupts: [],
+          checkpoint: null,
+          result: null,
+          state: {
+            values: {
+              city: "San Francisco",
+              messages: [
+                {
+                  content: "SF",
+                  additional_kwargs: {},
+                  response_metadata: {},
+                  type: "human",
+                  id: "initial-message",
+                },
+              ],
             },
-          ],
-          metadata: expect.any(Object),
-          created_at: expect.any(String),
-          checkpoint: expect.any(Object),
-          parent_checkpoint: expect.any(Object),
-          checkpoint_id: expect.any(String),
-          parent_checkpoint_id: expect.any(String),
+            next: ["weather_node"],
+            tasks: [
+              {
+                id: expect.any(String),
+                name: "weather_node",
+                path: ["__pregel_pull", "weather_node"],
+                error: null,
+                interrupts: [],
+                checkpoint: null,
+                state: null,
+                result: null,
+              },
+            ],
+            metadata: expect.any(Object),
+            created_at: expect.any(String),
+            checkpoint: expect.any(Object),
+            parent_checkpoint: expect.any(Object),
+            checkpoint_id: expect.any(String),
+            parent_checkpoint_id: expect.any(String),
+          },
         },
-      },
-    ]);
+      ]);
 
-    const threadAfterInterrupt = await client.threads.get(thread.thread_id);
-    expect(threadAfterInterrupt.status).toBe("interrupted");
+      const threadAfterInterrupt = await client.threads.get(thread.thread_id);
+      expect(threadAfterInterrupt.status).toBe("interrupted");
 
-    // continue after interrupt
-    const chunksSubgraph = await gatherIterator(
-      client.runs.stream(thread.thread_id, assistant.assistant_id, {
-        input: null,
-        streamMode: ["values", "updates"],
-        streamSubgraphs: true,
-      }),
-    );
+      // continue after interrupt
+      const chunksSubgraph = await gatherIterator(
+        client.runs.stream(thread.thread_id, assistant.assistant_id, {
+          input: null,
+          streamMode: ["values", "updates"],
+          streamSubgraphs: true,
+        }),
+      );
 
-    expect(chunksSubgraph.filter((i) => i.event === "error")).toEqual([]);
-    expect(chunksSubgraph.at(-1)?.event).toBe("values");
+      expect(chunksSubgraph.filter((i) => i.event === "error")).toEqual([]);
+      expect(chunksSubgraph.at(-1)?.event).toBe("values");
 
-    type ChunkType = (typeof chunksSubgraph)[number];
-    const continueMessages = findLast(
-      chunksSubgraph,
-      (i): i is ChunkType & { event: "values" } => 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(chunksSubgraph).toEqual([
-      {
-        event: "metadata",
-        data: { run_id: expect.any(String), attempt: 1 },
-      },
-      {
-        event: "values",
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
-            },
-          ],
-          route: "weather",
+      expect(continueMessages.length).toBe(2);
+      expect(continueMessages[0].content).toBe("SF");
+      expect(continueMessages[1].content).toBe("It's sunny in San Francisco!");
+      expect(chunksSubgraph).toEqual([
+        {
+          event: "metadata",
+          data: { run_id: expect.any(String), attempt: 1 },
         },
-      },
-      {
-        event: expect.stringMatching(/^values\|weather_graph:/),
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
+        {
+          event: "values",
+          data: {
+            messages: [
+              {
+                content: "SF",
+                additional_kwargs: {},
+                response_metadata: {},
+                type: "human",
+                id: "initial-message",
+              },
+            ],
+            route: "weather",
+          },
+        },
+        {
+          event: expect.stringMatching(/^values\|weather_graph:/),
+          data: {
+            messages: [
+              {
+                content: "SF",
+                additional_kwargs: {},
+                response_metadata: {},
+                type: "human",
+                id: "initial-message",
+              },
+            ],
+            city: "San Francisco",
+          },
+        },
+        {
+          event: expect.stringMatching(/^updates\|weather_graph:/),
+          data: {
+            weather_node: {
+              messages: [
+                {
+                  content: "It's sunny in San Francisco!",
+                  additional_kwargs: {},
+                  response_metadata: {},
+                  type: "ai",
+                  id: expect.any(String),
+                  tool_calls: [],
+                  invalid_tool_calls: [],
+                },
+              ],
             },
-          ],
-          city: "San Francisco",
+          },
         },
-      },
-      {
-        event: expect.stringMatching(/^updates\|weather_graph:/),
-        data: {
-          weather_node: {
+        {
+          event: expect.stringMatching(/^values\|weather_graph:/),
+          data: {
             messages: [
+              {
+                content: "SF",
+                additional_kwargs: {},
+                response_metadata: {},
+                type: "human",
+                id: "initial-message",
+              },
               {
                 content: "It's sunny in San Francisco!",
                 additional_kwargs: {},
@@ -1408,37 +1433,37 @@ describe("subgraphs", () => {
                 invalid_tool_calls: [],
               },
             ],
+            city: "San Francisco",
           },
         },
-      },
-      {
-        event: expect.stringMatching(/^values\|weather_graph:/),
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
-            },
-            {
-              content: "It's sunny in San Francisco!",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "ai",
-              id: expect.any(String),
-              tool_calls: [],
-              invalid_tool_calls: [],
+        {
+          event: "updates",
+          data: {
+            weather_graph: {
+              messages: [
+                {
+                  content: "SF",
+                  additional_kwargs: {},
+                  response_metadata: {},
+                  type: "human",
+                  id: "initial-message",
+                },
+                {
+                  content: "It's sunny in San Francisco!",
+                  additional_kwargs: {},
+                  response_metadata: {},
+                  type: "ai",
+                  id: expect.any(String),
+                  tool_calls: [],
+                  invalid_tool_calls: [],
+                },
+              ],
             },
-          ],
-          city: "San Francisco",
+          },
         },
-      },
-      {
-        event: "updates",
-        data: {
-          weather_graph: {
+        {
+          event: "values",
+          data: {
             messages: [
               {
                 content: "SF",
@@ -1457,41 +1482,18 @@ describe("subgraphs", () => {
                 invalid_tool_calls: [],
               },
             ],
+            route: "weather",
           },
         },
-      },
-      {
-        event: "values",
-        data: {
-          messages: [
-            {
-              content: "SF",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "human",
-              id: "initial-message",
-            },
-            {
-              content: "It's sunny in San Francisco!",
-              additional_kwargs: {},
-              response_metadata: {},
-              type: "ai",
-              id: expect.any(String),
-              tool_calls: [],
-              invalid_tool_calls: [],
-            },
-          ],
-          route: "weather",
-        },
-      },
-    ]);
+      ]);
 
-    const threadAfterContinue = await client.threads.get(thread.thread_id);
-    expect(threadAfterContinue.status).toBe("idle");
-  });
+      const threadAfterContinue = await client.threads.get(thread.thread_id);
+      expect(threadAfterContinue.status).toBe("idle");
+    },
+  );
 
   // (2) interrupt, modify the message and then continue running
-  it.concurrent("human in the loop - modification", {retry: 3}, async () => {
+  it.concurrent("human in the loop - modification", { retry: 3 }, async () => {
     const assistant = await client.assistants.create({ graphId: "weather" });
     const thread = await client.threads.create();
     const input = {
@@ -1993,3 +1995,88 @@ it("generative ui", async () => {
     client["~ui"].getComponent("non-existent", "none"),
   ).rejects.toThrow();
 });
+
+it("custom routes", async () => {
+  const fetcher = async (...args: Parameters<typeof fetch>) => {
+    const res = await fetch(...args);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return { json: await res.json(), headers: res.headers };
+  };
+
+  let res = await fetcher(new URL("/custom/my-route?aCoolParam=13", API_URL), {
+    headers: { "x-custom-input": "hey" },
+  });
+  expect(res.json).toEqual({ foo: "bar" });
+  expect(res.headers.get("x-custom-output")).toEqual("hey");
+  expect(res.headers.get("x-js-middleware")).toEqual("true");
+
+  res = await fetcher(new URL("/runs/afakeroute", API_URL));
+  expect(res.json).toEqual({ foo: "afakeroute" });
+
+  await expect(() =>
+    fetcher(new URL("/does/not/exist", API_URL)),
+  ).rejects.toThrow("404");
+
+  await expect(() =>
+    fetcher(new URL("/custom/error", API_URL)),
+  ).rejects.toThrow("400");
+
+  await expect(() =>
+    fetcher(new URL("/__langgraph_check", API_URL), { method: "OPTIONS" }),
+  ).rejects.toThrow("404");
+
+  const stream = await fetch(new URL("/custom/streaming", API_URL));
+  const reader = stream.body?.getReader();
+  if (!reader) throw new Error("No reader");
+
+  const chunks: string[] = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(new TextDecoder().decode(value));
+  }
+
+  expect(chunks.length).toBeGreaterThanOrEqual(4); // Must actually stream
+  expect(chunks.join("")).toEqual("Count: 0\nCount: 1\nCount: 2\nCount: 3\n");
+
+  const thread = await client.threads.create();
+  await client.runs.wait(thread.thread_id, "agent_simple", {
+    input: { messages: [{ role: "human", content: "foo" }] },
+    webhook: "/custom/webhook",
+  });
+
+  await expect
+    .poll(() => fetcher(new URL("/custom/webhook-payload", API_URL)), {
+      interval: 500,
+      timeout: 3000,
+    })
+    .toMatchObject({ json: { status: "success" } });
+
+  // check if custom middleware is applied even for python routes
+  res = await fetcher(new URL("/info", API_URL));
+  expect(res.headers.get("x-js-middleware")).toEqual("true");
+
+  // ... and if we can intercept a request targeted for Python API
+  res = await fetcher(new URL("/info?interrupt", API_URL));
+  expect(res.json).toEqual({ status: "interrupted" });
+});
+
+it("custom routes - mutate request body", async () => {
+  const client = new Client<any>({
+    apiUrl: API_URL,
+    defaultHeaders: {
+      "x-configurable-header": "extra-client",
+    },
+  });
+
+  const thread = await client.threads.create();
+  const res = await client.runs.wait(thread.thread_id, "agent_simple", {
+    input: { messages: [{ role: "human", content: "input" }] },
+  });
+
+  expect(res).toEqual({
+    messages: expect.arrayContaining([
+      expect.objectContaining({ content: "end: extra-client" }),
+    ]),
+  });
+});

langgraph_api/js/tests/compose-postgres.yml

@@ -34,8 +34,9 @@ services:
         ADD . /deps/graphs
         WORKDIR /deps/graphs
         RUN yarn install --frozen-lockfile
-        ENV LANGSERVE_GRAPHS='{"agent":"./agent.mts:graph", "nested": "./nested.mts:graph", "weather": "./weather.mts:graph", "error": "./error.mts:graph", "delay": "./delay.mts:graph", "dynamic": "./dynamic.mts:graph", "command": "./command.mts:graph"}'
+        ENV LANGSERVE_GRAPHS='{"agent":"./agent.mts:graph", "nested": "./nested.mts:graph", "weather": "./weather.mts:graph", "error": "./error.mts:graph", "delay": "./delay.mts:graph", "dynamic": "./dynamic.mts:graph", "command": "./command.mts:graph", "agent_simple": "./agent_simple.mts:graph"}'
         ENV LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}'
+        ENV LANGGRAPH_HTTP='{"app": "./http.mts:app"}'
         ENV LANGGRAPH_UI='{"agent": "./agent.ui.tsx"}'
         RUN tsx /api/langgraph_api/js/build.mts
     depends_on:

langgraph_api/js/tests/graphs/agent_simple.mts

@@ -29,7 +29,7 @@ const AgentState = Annotation.Root({
 
 async function callModel(
   state: typeof AgentState.State,
-  config: LangGraphRunnableConfig
+  config: LangGraphRunnableConfig,
 ): Promise<typeof AgentState.Update> {
   let userId: string | undefined;
 
@@ -41,6 +41,12 @@ async function callModel(
     userId = user?.identity;
   }
 
+  if (config.configurable?.["x-configurable-header"] != null) {
+    return {
+      messages: [`end: ${config.configurable?.["x-configurable-header"]}`],
+    };
+  }
+
   const model = getStableModel(config.configurable?.thread_id ?? "$");
   const existing = await config.store?.get([userId ?? "ALL"], "key_one");
   if (!existing) {
@@ -49,16 +55,15 @@ async function callModel(
   }
 
   const response = await model.invoke(state.messages);
-  const result: typeof AgentState.Update = { messages: [response] };
-  return result;
+  return { messages: [response] };
 }
 
 async function callTool(
-  message: BaseMessage
+  message: BaseMessage,
 ): Promise<typeof AgentState.Update> {
   const response = new ToolMessage(
     `tool_call__${message.content}`,
-    "tool_call_id"
+    "tool_call_id",
   );
   return { messages: [response] };
 }