langgraph-api 0.0.45__py3-none-any.whl → 0.0.47__py3-none-any.whl

langgraph_api/js/tests/api.test.mts

@@ -12,7 +12,7 @@ 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<any>({
@@ -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;
@@ -534,7 +534,7 @@ 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");
@@ -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,20 +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 as any).event),
-      ),
+          .map((i) => (i.data as any).event)
+      )
     ).toEqual(
       new Set([
         "on_chain_start",
@@ -627,7 +627,7 @@ describe("runs", () => {
         "on_chat_model_end",
         "on_chat_model_start",
         "on_chat_model_stream",
-      ]),
+      ])
     );
   });
 
@@ -640,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;
@@ -681,7 +681,7 @@ describe("runs", () => {
         "messages/metadata",
         "messages/partial",
         "messages/complete",
-      ]),
+      ])
     );
 
     expect(runId).not.toBeNull();
@@ -698,13 +698,13 @@ 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 is FeedbackStreamEvent => i.event === "metadata",
+      (i): i is FeedbackStreamEvent => i.event === "metadata"
     )?.data.run_id;
     expect(runId).not.toBeNull();
 
@@ -735,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);
@@ -744,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);
@@ -761,7 +761,7 @@ describe("runs", () => {
         "messages/partial",
         "messages/complete",
         "values",
-      ]),
+      ])
     );
 
     const run = await client.runs.get(thread.thread_id, runId!);
@@ -786,7 +786,7 @@ describe("runs", () => {
           input,
           interruptBefore: ["tool"],
           config: globalConfig,
-        }),
+        })
       );
 
       expect(chunks.filter((i) => i.event === "error").length).toBe(0);
@@ -806,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);
@@ -818,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 () => {
@@ -836,7 +836,7 @@ describe("runs", () => {
         input,
         interruptBefore: ["tool"],
         config: globalConfig,
-      }),
+      })
     );
 
     expect(chunks.filter((i) => i.event === "error").length).toBe(0);
@@ -844,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";
 
@@ -861,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"]);
@@ -874,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);
@@ -889,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);
@@ -935,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);
 
@@ -943,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);
   });
@@ -961,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
@@ -969,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);
@@ -995,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
     );
   });
 
@@ -1025,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
@@ -1122,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" };
@@ -1142,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();
@@ -1166,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"]);
@@ -1216,7 +1216,7 @@ describe("subgraphs", () => {
           messages: [{ role: "human", content: "SF", id: "initial-message" }],
         },
         interruptBefore: ["tool"],
-      }),
+      })
     );
 
     for (const chunk of chunks) {
@@ -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"]);
@@ -1343,7 +1343,7 @@ describe("subgraphs", () => {
         input: null,
         streamMode: ["values", "updates"],
         streamSubgraphs: true,
-      }),
+      })
     );
 
     expect(chunksSubgraph.filter((i) => i.event === "error")).toEqual([]);
@@ -1352,7 +1352,7 @@ describe("subgraphs", () => {
     type ChunkType = (typeof chunksSubgraph)[number];
     const continueMessages = findLast(
       chunksSubgraph,
-      (i): i is ChunkType & { event: "values" } => i.event === "values",
+      (i): i is ChunkType & { event: "values" } => i.event === "values"
     )?.data.messages;
 
     expect(continueMessages.length).toBe(2);
@@ -1500,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([]);
 
@@ -1532,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");
@@ -1554,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([]);
@@ -1639,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");
@@ -1656,7 +1656,7 @@ describe("errors", () => {
       client.runs.stream(thread.thread_id, assistant.assistant_id, {
         input: { messages: [] },
         streamMode: ["debug", "events"],
-      }),
+      })
     );
 
     expect(stream.at(-1)).toMatchObject({
@@ -1675,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);
@@ -1690,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({
@@ -1724,7 +1724,7 @@ describe("long running tasks", () => {
         {
           input: { messages: [], delay },
           config: globalConfig,
-        },
+        }
       );
 
       await client.runs.join(thread.thread_id, run.run_id);
@@ -1740,7 +1740,7 @@ describe("long running tasks", () => {
       expect(runResult.values.messages).toMatchObject([
         { content: `finished after ${delay}ms` },
       ]);
-    },
+    }
   );
 });
 
@@ -1765,12 +1765,11 @@ 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"
   );
 });
 
-// Not implemented in JS yet
-describe.skip("command update state", () => {
+describe("command update state", () => {
   it("updates state via commands", async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
@@ -1786,7 +1785,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([]);
 
@@ -1814,7 +1813,7 @@ describe.skip("command update state", () => {
           ],
         },
         config: globalConfig,
-      }),
+      })
     );
 
     expect(stream.filter((chunk) => chunk.event === "error")).toEqual([]);
@@ -1829,6 +1828,80 @@ describe.skip("command update state", () => {
       keyTwo: "value2",
     });
   });
+
+  it("goto skip start + map-reduce", async () => {
+    const assistant = await client.assistants.create({ graphId: "command" });
+    let thread = await client.threads.create();
+
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      command: { goto: "map" },
+      config: globalConfig,
+    });
+
+    let state = await client.threads.getState(thread.thread_id);
+    expect(state.values.messages).toEqual([
+      "map",
+      "task: 1",
+      "task: 2",
+      "task: 3",
+    ]);
+
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      command: {
+        goto: [
+          { node: "task", input: { value: 4 } },
+          { node: "task", input: { value: 5 } },
+          { node: "task", input: { value: 6 } },
+        ],
+      },
+      config: globalConfig,
+    });
+
+    state = await client.threads.getState(thread.thread_id);
+    expect(state.values.messages).toEqual([
+      "map",
+      "task: 1",
+      "task: 2",
+      "task: 3",
+      "task: 4",
+      "task: 5",
+      "task: 6",
+    ]);
+  });
+
+  it("goto interrupt", async () => {
+    const assistant = await client.assistants.create({ graphId: "command" });
+    let thread = await client.threads.create({ graphId: "command" });
+
+    let stream = await gatherIterator(
+      client.runs.stream(thread.thread_id, assistant.assistant_id, {
+        // TODO: figure out why we cannot go to the interrupt node directly
+        command: { goto: "before_interrupt" },
+      })
+    );
+
+    let state = await client.threads.getState(thread.thread_id);
+    expect(state.next).toEqual(["interrupt"]);
+    expect(state.tasks).toMatchObject([
+      {
+        name: "interrupt",
+        interrupts: [{ value: "interrupt", resumable: true, when: "during" }],
+      },
+    ]);
+
+    stream = await gatherIterator(
+      client.runs.stream(thread.thread_id, assistant.assistant_id, {
+        command: { resume: "resume" },
+        streamMode: ["updates"],
+      })
+    );
+
+    state = await client.threads.getState(thread.thread_id);
+    expect(state.values.messages).toEqual([
+      "before_interrupt",
+      "interrupt: resume",
+    ]);
+  });
 });
 
 it("dynamic graph", async () => {
@@ -1840,14 +1913,14 @@ it("dynamic graph", async () => {
     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)),
+        .flatMap((i) => Object.keys(i.data))
     )
     .toEqual(expect.arrayContaining(["default"]));
 
@@ -1856,14 +1929,14 @@ it("dynamic graph", async () => {
       input: { messages: ["input"] },
       config: { configurable: { nodeName: "runtime" } },
       streamMode: ["updates"],
-    }),
+    })
   );
 
   expect
     .soft(
       updates
         .filter((i) => i.event === "updates")
-        .flatMap((i) => Object.keys(i.data)),
+        .flatMap((i) => Object.keys(i.data))
     )
     .toEqual(expect.arrayContaining(["runtime"]));
 
@@ -1877,14 +1950,14 @@ it("dynamic graph", async () => {
     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)),
+        .flatMap((i) => Object.keys(i.data))
     )
     .toEqual(expect.arrayContaining(["assistant"]));
 
@@ -1900,3 +1973,23 @@ it("dynamic graph", async () => {
   const state = await client.threads.getState(thread.thread_id);
   expect(state.values.messages).toEqual(["input", "assistant", "update"]);
 });
+
+it("generative ui", async () => {
+  const ui = await client["~ui"].getComponent("agent", "weather-component");
+  expect(ui).toEqual(
+    `<script src="//localhost:9123/ui/agent/entrypoint.js" onload='__LGUI_agent.render("weather-component", "{{shadowRootId}}")'></script>\n<link rel="stylesheet" href="//localhost:9123/ui/agent/entrypoint.css" />`
+  );
+
+  const match = /src="(?<src>[^"]+)"/.exec(ui);
+  let jsFile = match?.groups?.src;
+  if (!jsFile) throw new Error("No JS file found");
+  if (jsFile.startsWith("//")) jsFile = "http:" + jsFile;
+
+  // Used to manually pass runtime dependencies
+  const js = await fetch(jsFile).then((a) => a.text());
+  expect(js).contains(`globalThis[Symbol.for("LGUI_REQUIRE")]`);
+
+  await expect(() =>
+    client["~ui"].getComponent("non-existent", "none")
+  ).rejects.toThrow();
+});