Skip to content

The Open Standard for Generative UI

Move useOpenuiCloudStorage to react-headless (#1179)

Visharad Kashyapbad6e492b38b
diff --git a/.changeset/cloud-storage-headless.md b/.changeset/cloud-storage-headless.md
new file mode 100644
index 000000000..74fce2162
--- /dev/null
+++ b/.changeset/cloud-storage-headless.md
@@ -0,0 +1,5 @@
+---
+"@openuidev/react-headless": patch
+---
+
+Export `useOpenuiCloudStorage`, `OpenuiCloudOptions`, and `OpenuiCloudFeatures` from `@openuidev/react-headless`, also available through `@openuidev/react-ui`. Cloud storage no longer requires importing the hook from `@openuidev/thesys`. The existing options, frontend-token refresh and retry behavior, conversation history, and optional artifact storage are preserved.
diff --git a/packages/react-headless/package.json b/packages/react-headless/package.json
index 291769ae0..42fc208a6 100644
--- a/packages/react-headless/package.json
+++ b/packages/react-headless/package.json
@@ -49,10 +49,14 @@
}
},
"devDependencies": {
+ "@types/node": "catalog:",
"@types/react": "catalog:",
+ "@types/react-dom": "catalog:",
"ai": "^6.0.236",
"eve": "^0.11.7",
+ "jsdom": "catalog:",
"openai": "^6.22.0",
+ "react-dom": "catalog:",
"vitest": "^4.1.0"
},
"keywords": [
diff --git a/packages/react-headless/src/cloud/__tests__/cloudStorage.test.ts b/packages/react-headless/src/cloud/__tests__/cloudStorage.test.ts
new file mode 100644
index 000000000..3562722a6
--- /dev/null
+++ b/packages/react-headless/src/cloud/__tests__/cloudStorage.test.ts
@@ -0,0 +1,288 @@
+import { describe, expect, it, vi } from "vitest";
+import type { UserMessage } from "../../types/message";
+import { cloudArtifactStorage } from "../artifactStorage";
+import { cloudItemsToMessages } from "../items";
+import { cloudThreadStorage, deriveTitle } from "../threadStorage";
+import type { CloudArtifact, CloudConversationItem } from "../wire";
+
+const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status });
+const baseUrl = "https://cloud.example.com/";
+const conversation = { id: "c 1", object: "conversation", created_at: 1700000000, title: "Hello" };
+const artifact: CloudArtifact = {
+ id: "a/1",
+ object: "openui.artifact",
+ conversation_id: "c1",
+ kind: "report",
+ name: "Q2",
+ content: "root = ReportView()",
+ created_at: 100,
+ updated_at: 200,
+};
+
+function item(id: string, fields: Partial<CloudConversationItem>): CloudConversationItem {
+ return { id, object: "conversation.item", created_at: 1, type: "message", ...fields };
+}
+
+describe("cloud conversations", () => {
+ it("lists threads with an encoded cursor and maps timestamps and missing titles", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(
+ json({
+ data: [conversation, { ...conversation, id: "c2", title: undefined }],
+ has_more: true,
+ last_id: "c2",
+ }),
+ );
+ const storage = cloudThreadStorage({ baseUrl, fetch, pageLimit: 20 });
+ expect(await storage.listThreads("c&0")).toEqual({
+ threads: [
+ { id: "c 1", title: "Hello", createdAt: 1700000000000 },
+ { id: "c2", title: "New conversation", createdAt: 1700000000000 },
+ ],
+ nextCursor: "c2",
+ });
+ expect(fetch.mock.calls[0]![0]).toBe(
+ "https://cloud.example.com/v1/conversations?limit=20&after=c%260",
+ );
+ });
+
+ it("creates and renames threads with only the title and encodes IDs for rename/delete", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(json(conversation))
+ .mockResolvedValueOnce(json({ ...conversation, title: "Renamed" }))
+ .mockResolvedValueOnce(new Response(null, { status: 204 }));
+ const storage = cloudThreadStorage({ baseUrl, fetch });
+ const thread = await storage.createThread({ id: "m1", role: "user", content: " Hello " });
+ expect(fetch.mock.calls[0]).toEqual([
+ "https://cloud.example.com/v1/conversations",
+ {
+ method: "POST",
+ body: JSON.stringify({ title: "Hello" }),
+ headers: { "Content-Type": "application/json" },
+ },
+ ]);
+ expect(await storage.updateThread({ ...thread, title: "Renamed" })).toEqual({
+ ...thread,
+ title: "Renamed",
+ });
+ expect(fetch.mock.calls[1]).toEqual([
+ "https://cloud.example.com/v1/conversations/c%201",
+ {
+ method: "POST",
+ body: JSON.stringify({ title: "Renamed" }),
+ headers: { "Content-Type": "application/json" },
+ },
+ ]);
+ await storage.deleteThread(thread.id);
+ expect(fetch.mock.calls[2]).toEqual([
+ "https://cloud.example.com/v1/conversations/c%201",
+ { method: "DELETE", headers: {} },
+ ]);
+ });
+
+ it.each([
+ [" Hello ", "Hello"],
+ ["", "New conversation"],
+ ["x".repeat(80), "x".repeat(60)],
+ [
+ [
+ { type: "binary", mimeType: "image/png", url: "https://example.com/image.png" },
+ { type: "text", text: " " },
+ { type: "text", text: " From parts " },
+ ],
+ "From parts",
+ ],
+ ] satisfies [UserMessage["content"], string][])("derives a title from %j", (content, title) => {
+ expect(deriveTitle({ id: "m1", role: "user", content })).toBe(title);
+ });
+
+ it("loads all pages in order and groups tool calls/results spanning page boundaries", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(
+ json({
+ data: [
+ item("u1", { role: "user", content: "hi" }),
+ item("a1", { role: "assistant", content: [{ type: "output_text", text: "Working" }] }),
+ item("f1", {
+ type: "function_call",
+ call_id: "call1",
+ name: "search",
+ arguments: "{}",
+ }),
+ ],
+ has_more: true,
+ last_id: "f1",
+ }),
+ )
+ .mockResolvedValueOnce(
+ json({
+ data: [
+ item("o1", { type: "function_call_output", call_id: "call1", output: { found: true } }),
+ item("f2", {
+ type: "function_call",
+ call_id: "call2",
+ name: "report",
+ arguments: "{}",
+ }),
+ item("o2", { type: "function_call_output", call_id: "call2", output: "done" }),
+ ],
+ has_more: false,
+ last_id: "o2",
+ }),
+ );
+ const messages = await cloudThreadStorage({ baseUrl, fetch }).getMessages("c/1");
+ expect(fetch.mock.calls.map(([url]) => url)).toEqual([
+ "https://cloud.example.com/v1/conversations/c%2F1/items?order=asc&limit=100",
+ "https://cloud.example.com/v1/conversations/c%2F1/items?order=asc&limit=100&after=f1",
+ ]);
+ expect(messages).toEqual([
+ { id: "u1", role: "user", content: "hi" },
+ {
+ id: "a1",
+ role: "assistant",
+ content: "Working",
+ toolCalls: [
+ { id: "call1", type: "function", function: { name: "search", arguments: "{}" } },
+ { id: "call2", type: "function", function: { name: "report", arguments: "{}" } },
+ ],
+ },
+ { id: "o1", role: "tool", toolCallId: "call1", content: '{"found":true}' },
+ { id: "o2", role: "tool", toolCallId: "call2", content: "done" },
+ ]);
+ });
+
+ it("stops pagination when the server omits its cursor", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValue(json({ data: [], has_more: true }));
+ expect(await cloudThreadStorage({ baseUrl, fetch }).getMessages("c1")).toEqual([]);
+ expect(fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it("surfaces API failures with the operation and status", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(json({}, 500));
+ await expect(cloudThreadStorage({ baseUrl, fetch }).deleteThread("c1")).rejects.toThrow(
+ "OpenUI Cloud: DELETE /v1/conversations/c1 failed: 500",
+ );
+ });
+});
+
+describe("cloud artifacts", () => {
+ it("maps summaries and forwards search, types, pagination, and page size", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(
+ json({
+ data: [artifact],
+ has_more: true,
+ last_id: "a/1",
+ }),
+ );
+ const result = await cloudArtifactStorage({ baseUrl, fetch }).list({
+ name: "Q2 & Q3",
+ type: ["slides", "report"],
+ cursor: "a0",
+ limit: 25,
+ });
+ expect(fetch.mock.calls[0]![0]).toBe(
+ "https://cloud.example.com/v1/artifacts?name=Q2+%26+Q3&kind=slides&kind=report&after=a0&limit=25",
+ );
+ expect(result).toEqual({
+ artifacts: [{ id: "a/1", title: "Q2", type: "report", threadId: "c1", updatedAt: 200000 }],
+ nextCursor: "a/1",
+ });
+ expect(result.artifacts[0]).not.toHaveProperty("content");
+ });
+
+ it("uses default list options and omits a cursor on the final page", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(
+ json({
+ data: [],
+ has_more: false,
+ last_id: "a1",
+ }),
+ );
+ expect(await cloudArtifactStorage({ baseUrl, fetch }).list()).toEqual({
+ artifacts: [],
+ nextCursor: undefined,
+ });
+ expect(fetch.mock.calls[0]![0]).toBe("https://cloud.example.com/v1/artifacts?limit=100");
+ });
+
+ it("reads content and falls back to the artifact ID and creation time", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(
+ json({
+ ...artifact,
+ name: undefined,
+ updated_at: undefined,
+ }),
+ );
+ expect(await cloudArtifactStorage({ baseUrl, fetch }).get("a/1")).toEqual({
+ id: "a/1",
+ title: "a/1",
+ type: "report",
+ threadId: "c1",
+ updatedAt: 100000,
+ content: artifact.content,
+ });
+ expect(fetch.mock.calls[0]![0]).toBe("https://cloud.example.com/v1/artifacts/a%2F1");
+ });
+
+ it.each([artifact.content, { root: "ReportView" }])(
+ "updates %j as a string without a version",
+ async (content) => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(json(artifact));
+ const result = await cloudArtifactStorage({ baseUrl, fetch }).update({ id: "a/1", content });
+ expect(fetch.mock.calls[0]).toEqual([
+ "https://cloud.example.com/v1/artifacts/a%2F1",
+ {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ content: typeof content === "string" ? content : JSON.stringify(content),
+ }),
+ },
+ ]);
+ expect(result).not.toHaveProperty("content");
+ },
+ );
+});
+
+describe("cloud item conversion", () => {
+ it("skips unsupported and malformed tool rows while retaining valid messages", () => {
+ expect(
+ cloudItemsToMessages([
+ item("unknown", { type: "reasoning" }),
+ item("bad-call", { type: "function_call" }),
+ item("bad-output", { type: "function_call_output", call_id: "call" }),
+ item("u1", { role: "user", content: "hi" }),
+ item("a1", { role: "assistant", content: "hello" }),
+ ]),
+ ).toEqual([
+ { id: "u1", role: "user", content: "hi" },
+ { id: "a1", role: "assistant", content: "hello" },
+ ]);
+ });
+
+ it("preserves multipart user input", () => {
+ expect(
+ cloudItemsToMessages([
+ item("u1", {
+ role: "user",
+ content: [
+ { type: "input_text", text: "Describe this" },
+ { type: "input_image", image_url: "https://example.com/image.png" },
+ ],
+ }),
+ ]),
+ ).toEqual([
+ {
+ id: "u1",
+ role: "user",
+ content: [
+ { type: "text", text: "Describe this" },
+ { type: "binary", url: "https://example.com/image.png", mimeType: "image/*" },
+ ],
+ },
+ ]);
+ });
+});
diff --git a/packages/react-headless/src/cloud/__tests__/frontendTokenManager.test.ts b/packages/react-headless/src/cloud/__tests__/frontendTokenManager.test.ts
new file mode 100644
index 000000000..bf3f30820
--- /dev/null
+++ b/packages/react-headless/src/cloud/__tests__/frontendTokenManager.test.ts
@@ -0,0 +1,134 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+ createFctFetch,
+ createFrontendTokenManager,
+ FRONTEND_TOKEN_HEADER,
+} from "../frontendTokenManager";
+
+const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status });
+const mintResponse = (token: string) => json({ token, expires_at: Date.now() / 1000 + 900 });
+
+afterEach(() => vi.useRealTimers());
+
+describe("frontend tokens", () => {
+ it("mints lazily, shares concurrent requests, and refreshes before expiry", async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(0);
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(json({ token: "first", expires_at: 900 }))
+ .mockResolvedValueOnce(json({ token: "second", expires_at: 1800 }));
+ const tokens = createFrontendTokenManager({ mintUrl: "/api/token", fetch });
+ expect(fetch).not.toHaveBeenCalled();
+
+ expect(await Promise.all([tokens.getToken(), tokens.getToken()])).toEqual(["first", "first"]);
+ expect(fetch).toHaveBeenCalledExactlyOnceWith("/api/token", { method: "POST" });
+ vi.setSystemTime(839_000);
+ expect(await tokens.getToken()).toBe("first");
+ expect(fetch).toHaveBeenCalledTimes(1);
+ vi.setSystemTime(840_000);
+ expect(await tokens.getToken()).toBe("second");
+ expect(fetch).toHaveBeenCalledTimes(2);
+ });
+
+ it("honors a custom refresh skew", async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(0);
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(json({ token: "first", expires_at: 900 }))
+ .mockResolvedValueOnce(json({ token: "second", expires_at: 1800 }));
+ const tokens = createFrontendTokenManager({
+ mintUrl: "/api/token",
+ fetch,
+ refreshSkewSeconds: 120,
+ });
+ await tokens.getToken();
+ vi.setSystemTime(780_000);
+ expect(await tokens.getToken()).toBe("second");
+ });
+
+ it("keeps a refreshed token when an older concurrent request invalidates its token", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(mintResponse("old"))
+ .mockResolvedValueOnce(mintResponse("new"))
+ .mockResolvedValueOnce(mintResponse("next"));
+ const tokens = createFrontendTokenManager({ mintUrl: "/api/token", fetch });
+ await tokens.getToken();
+ tokens.invalidate("old");
+ expect(await tokens.getToken()).toBe("new");
+ tokens.invalidate("old");
+ expect(await tokens.getToken()).toBe("new");
+ expect(fetch).toHaveBeenCalledTimes(2);
+ tokens.invalidate();
+ expect(await tokens.getToken()).toBe("next");
+ });
+
+ it.each(["http", "network"] as const)(
+ "allows another mint after a %s failure",
+ async (failure) => {
+ const fetch = vi.fn<typeof globalThis.fetch>();
+ if (failure === "http") fetch.mockResolvedValueOnce(json({}, 503));
+ else fetch.mockRejectedValueOnce(new Error("offline"));
+ fetch.mockResolvedValueOnce(mintResponse("recovered"));
+ const tokens = createFrontendTokenManager({ mintUrl: "/api/token", fetch });
+ await expect(tokens.getToken()).rejects.toThrow(
+ failure === "http" ? "frontend-token mint failed: 503" : "offline",
+ );
+ expect(await tokens.getToken()).toBe("recovered");
+ },
+ );
+});
+
+describe("authenticated fetch", () => {
+ it("refreshes on 401 and retries once with the same request body and custom headers", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(json({}, 401))
+ .mockResolvedValueOnce(json({ ok: true }));
+ const tokens = {
+ getToken: vi.fn().mockResolvedValueOnce("old").mockResolvedValueOnce("new"),
+ invalidate: vi.fn(),
+ };
+ const headers = new Headers({ "Content-Type": "application/json", "X-Custom": "kept" });
+ const body = JSON.stringify({ title: "Hello" });
+ const response = await createFctFetch(tokens, fetch)("/v1/conversations", {
+ method: "POST",
+ headers,
+ body,
+ });
+ expect(response.status).toBe(200);
+ expect(tokens.invalidate).toHaveBeenCalledWith("old");
+ for (const [index, token] of ["old", "new"].entries()) {
+ const [url, init] = fetch.mock.calls[index]!;
+ expect(url).toBe("/v1/conversations");
+ expect(init).toMatchObject({ method: "POST", body });
+ const sentHeaders = new Headers(init?.headers);
+ expect(sentHeaders.get(FRONTEND_TOKEN_HEADER)).toBe(token);
+ expect(sentHeaders.get("Content-Type")).toBe("application/json");
+ expect(sentHeaders.get("X-Custom")).toBe("kept");
+ expect(sentHeaders.has("Authorization")).toBe(false);
+ }
+ expect(headers.has(FRONTEND_TOKEN_HEADER)).toBe(false);
+ });
+
+ it.each([401, 403, 500])("bounds retries for status %i", async (status) => {
+ const fetch = vi.fn<typeof globalThis.fetch>().mockImplementation(async () => json({}, status));
+ const tokens = { getToken: vi.fn().mockResolvedValue("token"), invalidate: vi.fn() };
+ const response = await createFctFetch(tokens, fetch)("/v1/conversations");
+ expect(response.status).toBe(status);
+ expect(fetch).toHaveBeenCalledTimes(status === 401 ? 2 : 1);
+ expect(tokens.invalidate).toHaveBeenCalledTimes(status === 401 ? 1 : 0);
+ });
+
+ it("does not send a storage request when minting fails", async () => {
+ const fetch = vi.fn<typeof globalThis.fetch>();
+ const tokens = {
+ getToken: vi.fn().mockRejectedValue(new Error("mint failed")),
+ invalidate: vi.fn(),
+ };
+ await expect(createFctFetch(tokens, fetch)("/v1/conversations")).rejects.toThrow("mint failed");
+ expect(fetch).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/react-headless/src/cloud/__tests__/useOpenuiCloudStorage.test.tsx b/packages/react-headless/src/cloud/__tests__/useOpenuiCloudStorage.test.tsx
new file mode 100644
index 000000000..d2e80d6d1
--- /dev/null
+++ b/packages/react-headless/src/cloud/__tests__/useOpenuiCloudStorage.test.tsx
@@ -0,0 +1,147 @@
+// @vitest-environment jsdom
+import { act, StrictMode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useOpenuiCloudStorage, type ChatStorage, type OpenuiCloudOptions } from "../../index";
+
+const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status });
+const emptyList = { data: [], has_more: false };
+
+describe("useOpenuiCloudStorage", () => {
+ let root: Root;
+ let container: HTMLDivElement;
+ let storage: ChatStorage;
+
+ beforeEach(() => {
+ vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+ container = document.createElement("div");
+ document.body.append(container);
+ root = createRoot(container);
+ });
+
+ afterEach(async () => {
+ await act(async () => root.unmount());
+ container.remove();
+ vi.unstubAllGlobals();
+ });
+
+ function Harness({ options }: { options: OpenuiCloudOptions }) {
+ storage = useOpenuiCloudStorage(options);
+ return null;
+ }
+
+ async function render(options: OpenuiCloudOptions) {
+ await act(async () => {
+ root.render(
+ <StrictMode>
+ <Harness options={options} />
+ </StrictMode>,
+ );
+ });
+ return storage;
+ }
+
+ it("does no network work during render and shares a cached token across storage channels", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockImplementation(async (input) =>
+ json(
+ input === "/api/token"
+ ? { token: "session", expires_at: Date.now() / 1000 + 900 }
+ : emptyList,
+ ),
+ );
+ await render({ token: "/api/token", fetch });
+ expect(fetch).not.toHaveBeenCalled();
+ expect(storage.artifact).toBeDefined();
+ await Promise.all([storage.thread.listThreads(), storage.artifact!.list()]);
+ expect(fetch.mock.calls.map(([input]) => input)).toEqual([
+ "/api/token",
+ "https://api.thesys.dev/v1/conversations?limit=100",
+ "https://api.thesys.dev/v1/artifacts?limit=100",
+ ]);
+ for (const [, init] of fetch.mock.calls.slice(1)) {
+ expect(new Headers(init?.headers).get("x-thesys-frontend-token")).toBe("session");
+ }
+ });
+
+ it("keeps storage and token cache stable when inline option objects are recreated", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockImplementation(async (input) =>
+ json(
+ input === "/api/token"
+ ? { token: "session", expires_at: Date.now() / 1000 + 900 }
+ : emptyList,
+ ),
+ );
+ const first = await render({ token: "/api/token", fetch });
+ await first.thread.listThreads();
+ const second = await render({ token: "/api/token", fetch, features: { artifact: true } });
+ expect(second).toBe(first);
+ await second.thread.listThreads();
+ expect(fetch.mock.calls.filter(([input]) => input === "/api/token")).toHaveLength(1);
+ });
+
+ it.each([
+ { token: "/api/another-user/token" },
+ { apiBaseUrl: "https://cloud.example.com" },
+ { refreshSkewSeconds: 120 },
+ { features: { artifact: false } },
+ { fetch: vi.fn<typeof globalThis.fetch>() },
+ ] satisfies Partial<OpenuiCloudOptions>[])(
+ "recreates storage when an option changes: %j",
+ async (change) => {
+ const fetch = vi.fn<typeof globalThis.fetch>();
+ const first = await render({ token: "/api/token", fetch });
+ const next = await render({ token: "/api/token", fetch, ...change });
+ expect(next).not.toBe(first);
+ expect(fetch).not.toHaveBeenCalled();
+ },
+ );
+
+ it("uses the new mint endpoint after a token URL change", async () => {
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockImplementation(async (input) =>
+ json(
+ String(input).startsWith("/api/")
+ ? { token: String(input), expires_at: Date.now() / 1000 + 900 }
+ : emptyList,
+ ),
+ );
+ await render({ token: "/api/alice/token", fetch });
+ await storage.thread.listThreads();
+ await render({ token: "/api/bob/token", fetch });
+ await storage.thread.listThreads();
+ expect(fetch.mock.calls[2]![0]).toBe("/api/bob/token");
+ expect(new Headers(fetch.mock.calls[3]![1]?.headers).get("x-thesys-frontend-token")).toBe(
+ "/api/bob/token",
+ );
+ });
+
+ it("supports a token provider, custom origin, disabled artifacts, and a reactive retry", async () => {
+ const token = vi.fn().mockResolvedValueOnce("expired").mockResolvedValueOnce("fresh");
+ const fetch = vi
+ .fn<typeof globalThis.fetch>()
+ .mockResolvedValueOnce(json({}, 401))
+ .mockResolvedValueOnce(json(emptyList));
+ await render({
+ token,
+ fetch,
+ apiBaseUrl: "https://cloud.example.com/",
+ features: { artifact: false },
+ });
+ expect(storage.artifact).toBeUndefined();
+ expect(token).not.toHaveBeenCalled();
+ await storage.thread.listThreads();
+ expect(token).toHaveBeenCalledTimes(2);
+ expect(fetch.mock.calls.map(([input]) => input)).toEqual([
+ "https://cloud.example.com/v1/conversations?limit=100",
+ "https://cloud.example.com/v1/conversations?limit=100",
+ ]);
+ expect(new Headers(fetch.mock.calls[1]![1]?.headers).get("x-thesys-frontend-token")).toBe(
+ "fresh",
+ );
+ });
+});
diff --git a/packages/react-headless/src/cloud/artifactStorage.ts b/packages/react-headless/src/cloud/artifactStorage.ts
new file mode 100644
index 000000000..d4c2ce507
--- /dev/null
+++ b/packages/react-headless/src/cloud/artifactStorage.ts
@@ -0,0 +1,72 @@
+import type {
+ Artifact,
+ ArtifactListParams,
+ ArtifactStorage,
+ ArtifactSummary,
+} from "../adapters/types";
+import { cloudRequest, nextCursorOf, type CloudArtifact, type CloudListEnvelope } from "./wire";
+
+export interface CloudArtifactStorageOptions {
+ /** OpenUI Cloud API origin, e.g. "http://localhost:3102". */
+ baseUrl: string;
+ /** The token-injecting fetch from createFctFetch. */
+ fetch: typeof fetch;
+ /** Default page size when the caller passes no limit. */
+ pageLimit?: number;
+}
+
+function toSummary(artifact: CloudArtifact): ArtifactSummary {
+ return {
+ id: artifact.id,
+ title: artifact.name ?? artifact.id,
+ type: artifact.kind,
+ threadId: artifact.conversation_id,
+ updatedAt: (artifact.updated_at ?? artifact.created_at) * 1000,
+ };
+}
+
+export function cloudArtifactStorage({
+ baseUrl,
+ fetch: fetchImpl,
+ pageLimit = 100,
+}: CloudArtifactStorageOptions): ArtifactStorage {
+ const request = cloudRequest(fetchImpl, baseUrl);
+
+ return {
+ /** GET /v1/artifacts?[name=][kind=…]&limit[&after=]. Omitting the
+ * conversation scope lists across conversations, token-scoped to the user. */
+ async list(params?: ArtifactListParams) {
+ const query = new URLSearchParams();
+ if (params?.name !== undefined && params.name !== "") query.set("name", params.name);
+ for (const type of params?.type ?? []) query.append("kind", type);
+ if (params?.cursor !== undefined) query.set("after", params.cursor);
+ query.set("limit", String(params?.limit ?? pageLimit));
+ const res = await request(`/v1/artifacts?${query.toString()}`);
+ const envelope = (await res.json()) as CloudListEnvelope<CloudArtifact>;
+ return {
+ artifacts: envelope.data.map(toSummary),
+ nextCursor: nextCursorOf(envelope),
+ };
+ },
+
+ /** GET /v1/artifacts/:id → the stored openui-lang program (bare program;
+ * the renderer's parser sniffs the `root = …` root). */
+ async get(id: string): Promise<Artifact> {
+ const res = await request(`/v1/artifacts/${encodeURIComponent(id)}`);
+ const artifact = (await res.json()) as CloudArtifact;
+ return { ...toSummary(artifact), content: artifact.content };
+ },
+
+ /** POST /v1/artifacts/:id {content}. Send the edited inner program (a
+ * string); omit version to let the server bump it. */
+ async update(patch: { id: string; content: unknown }): Promise<ArtifactSummary> {
+ const content =
+ typeof patch.content === "string" ? patch.content : JSON.stringify(patch.content);
+ const res = await request(`/v1/artifacts/${encodeURIComponent(patch.id)}`, {
+ method: "POST",
+ body: JSON.stringify({ content }),
+ });
+ return toSummary((await res.json()) as CloudArtifact);
+ },
+ };
+}
diff --git a/packages/react-headless/src/cloud/frontendTokenManager.ts b/packages/react-headless/src/cloud/frontendTokenManager.ts
new file mode 100644
index 000000000..c6e16290b
--- /dev/null
+++ b/packages/react-headless/src/cloud/frontendTokenManager.ts
@@ -0,0 +1,112 @@
+/**
+ * Frontend session-token (fct_) lifecycle for the browser plane.
+ *
+ * - The token rides ONLY the `x-thesys-frontend-token` header; `Authorization`
+ * on /v1/* always means the master key (server-side).
+ * - Minting happens on YOUR backend (here, the /api/frontend-token proxy),
+ * which calls the cloud mint endpoint with the master key and decides the
+ * end-user identity server-side. The browser sends no body and never names
+ * its own user.
+ * - Mint response: { token: 'fct_…', expires_at: <unix seconds> }, TTL ~15 min.
+ *
+ * A fetch override (not static headers) is used so the token can refresh
+ * mid-session — the chat provider captures the storage object once at mount.
+ */
+
+export const FRONTEND_TOKEN_HEADER = "x-thesys-frontend-token";
+
+export interface MintFrontendTokenResponse {
+ token: string;
+ expires_at: number; // unix seconds
+}
+
+export interface FrontendTokenManagerOptions {
+ /** Your backend mint endpoint, e.g. "/api/frontend-token". */
+ mintUrl: string;
+ /** Override for tests / SSR. Defaults to globalThis.fetch. */
+ fetch?: typeof fetch;
+ /** Refresh this many seconds before expiry. Default 60. */
+ refreshSkewSeconds?: number;
+}
+
+export interface FrontendTokenManager {
+ /** A token valid for at least refreshSkewSeconds (single-flight mint). */
+ getToken(): Promise<string>;
+ /** Drop the cached token. Pass the token that 401'd so a concurrent refresh
+ * is not discarded. */
+ invalidate(staleToken?: string): void;
+}
+
+export function createFrontendTokenManager({
+ mintUrl,
+ fetch: customFetch,
+ refreshSkewSeconds = 60,
+}: FrontendTokenManagerOptions): FrontendTokenManager {
+ const fetchImpl = customFetch ?? globalThis.fetch.bind(globalThis);
+
+ let token: string | null = null;
+ let expiresAt = 0; // unix seconds
+ let inflight: Promise<string> | null = null;
+
+ const mint = async (): Promise<string> => {
+ const res = await fetchImpl(mintUrl, { method: "POST" });
+ if (!res.ok) {
+ throw new Error(`frontend-token mint failed: ${res.status} ${res.statusText}`);
+ }
+ const body = (await res.json()) as MintFrontendTokenResponse;
+ token = body.token;
+ expiresAt = body.expires_at;
+ return body.token;
+ };
+
+ return {
+ async getToken(): Promise<string> {
+ const nowSeconds = Date.now() / 1000;
+ if (token !== null && nowSeconds < expiresAt - refreshSkewSeconds) return token;
+ // Single-flight: callers during a refresh await the same mint.
+ if (inflight === null) {
+ inflight = mint().finally(() => {
+ inflight = null;
+ });
+ }
+ return inflight;
+ },
+
+ invalidate(staleToken?: string): void {
+ if (staleToken === undefined || staleToken === token) {
+ token = null;
+ expiresAt = 0;
+ }
+ },
+ };
+}
+
+/**
+ * Wrap a base fetch so every request carries a fresh token, with one reactive
+ * retry on 401. The request is re-sent with the same init — pass re-readable
+ * (string) bodies only.
+ */
+export function createFctFetch(
+ tokens: FrontendTokenManager,
+ baseFetch?: typeof fetch,
+): typeof fetch {
+ const fetchImpl = baseFetch ?? globalThis.fetch.bind(globalThis);
+
+ return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+ const token = await tokens.getToken();
+ const headers = new Headers(init?.headers);
+ headers.set(FRONTEND_TOKEN_HEADER, token);
+
+ let res = await fetchImpl(input, { ...init, headers });
+
+ if (res.status === 401) {
+ tokens.invalidate(token);
+ const freshToken = await tokens.getToken();
+ const retryHeaders = new Headers(init?.headers);
+ retryHeaders.set(FRONTEND_TOKEN_HEADER, freshToken);
+ res = await fetchImpl(input, { ...init, headers: retryHeaders });
+ }
+
+ return res;
+ };
+}
diff --git a/packages/react-headless/src/cloud/items.ts b/packages/react-headless/src/cloud/items.ts
new file mode 100644
index 000000000..d1e09a55a
--- /dev/null
+++ b/packages/react-headless/src/cloud/items.ts
@@ -0,0 +1,73 @@
+import { openAIConversationMessageFormat } from "../stream/formats/openai-conversation-message-format";
+import type { Message } from "../types/message";
+import type { CloudConversationItem } from "./wire";
+
+/**
+ * Convert /v1 conversation items to AG-UI Message[]. Each item is normalized
+ * into the OpenAI ConversationItem shape that openAIConversationMessageFormat
+ * .fromApi expects, then delegated — the grouping logic (function_call →
+ * assistant toolCalls, function_call_output → ToolMessage) stays in the SDK.
+ *
+ * Normalizations:
+ * - message content: assistant outputs arrive as part arrays; user inputs
+ * arrive as a plain string → wrap strings as a single text part.
+ * - function_call / function_call_output: a malformed row (missing the
+ * top-level call_id/name/output) is skipped so it can't crash fromApi.
+ * - other item types are skipped.
+ */
+function normalizeItem(item: CloudConversationItem): Record<string, unknown> | null {
+ switch (item.type) {
+ case "message": {
+ const content = item.content;
+ const parts = Array.isArray(content)
+ ? content
+ : [
+ {
+ type: item.role === "assistant" ? "output_text" : "input_text",
+ text: typeof content === "string" ? content : "",
+ },
+ ];
+ return {
+ id: item.id,
+ type: "message",
+ role: item.role ?? "user",
+ status: item.status ?? "completed",
+ content: parts,
+ };
+ }
+
+ case "function_call": {
+ if (typeof item.call_id !== "string" || typeof item.name !== "string") return null;
+ return {
+ id: item.id,
+ type: "function_call",
+ call_id: item.call_id,
+ name: item.name,
+ arguments:
+ typeof item.arguments === "string"
+ ? item.arguments
+ : JSON.stringify(item.arguments ?? {}),
+ };
+ }
+
+ case "function_call_output": {
+ if (typeof item.call_id !== "string" || item.output === undefined) return null;
+ return {
+ id: item.id,
+ type: "function_call_output",
+ call_id: item.call_id,
+ output: item.output,
+ };
+ }
+
+ default:
+ return null;
+ }
+}
+
+export function cloudItemsToMessages(items: CloudConversationItem[]): Message[] {
+ const normalized = items
+ .map(normalizeItem)
+ .filter((i): i is Record<string, unknown> => i !== null);
+ return openAIConversationMessageFormat.fromApi(normalized);
+}
diff --git a/packages/react-headless/src/cloud/openuiCloud.ts b/packages/react-headless/src/cloud/openuiCloud.ts
new file mode 100644
index 000000000..2733aca0e
--- /dev/null
+++ b/packages/react-headless/src/cloud/openuiCloud.ts
@@ -0,0 +1,115 @@
+"use client";
+
+import { useMemo } from "react";
+import type { ChatStorage } from "../adapters/types";
+
+import { cloudArtifactStorage } from "./artifactStorage";
+import {
+ createFctFetch,
+ createFrontendTokenManager,
+ type FrontendTokenManager,
+} from "./frontendTokenManager";
+import { cloudThreadStorage } from "./threadStorage";
+
+/** Which storage surfaces useOpenuiCloudStorage wires. */
+export interface OpenuiCloudFeatures {
+ /** Stored-artifact reads + edits. Default true. */
+ artifact?: boolean;
+}
+
+export interface OpenuiCloudOptions {
+ /**
+ * The OpenUI Cloud API origin. Defaults to "https://api.thesys.dev" (the
+ * storage layer appends `/v1/...`). Set this to e.g. "http://localhost:3102"
+ * to run against a local stack. The browser calls this directly with the
+ * fct_ token — there is no same-origin proxy in between.
+ */
+ apiBaseUrl?: string;
+ /**
+ * Where the short-lived fct_ session token comes from — either a URL of your
+ * backend mint endpoint (POST → { token, expires_at }, cached + refreshed
+ * here) or a function returning a fresh token (you own caching). The token
+ * rides the `x-thesys-frontend-token` header on every /v1 call. The frontend
+ * token is minted server-side; the master key never reaches the browser.
+ */
+ token: string | (() => Promise<string>);
+ /** Which storage surfaces to wire. Omit to enable all. */
+ features?: OpenuiCloudFeatures;
+ /** fetch override (tests / SSR). Defaults to globalThis.fetch. */
+ fetch?: typeof fetch;
+ /** Refresh the cached token this many seconds before expiry (URL form). Default 60. */
+ refreshSkewSeconds?: number;
+}
+
+/** OpenUI Cloud API origin used when `apiBaseUrl` is omitted. The storage
+ * layer appends `/v1/...` to it. */
+const DEFAULT_API_BASE_URL = "https://api.thesys.dev";
+
+/**
+ * One-call browser wiring for OpenUI Cloud, as a hook: a memoised `ChatStorage`
+ * backed by the /v1 API, authenticated per-request with an fct_ session token.
+ * Pass it straight to `<AgentInterface storage={…} />`.
+ *
+ * As a hook the storage (and its fct_ token manager) is created on mount and
+ * re-created only when its options change. Tokens are minted lazily on the first
+ * storage request. ChatProvider captures storage at mount; remount the provider
+ * when switching users or storage configurations.
+ *
+ * This is the READ/EDIT plane (browser → /v1/* with the fct_ token). Generation
+ * is the separate ChatLLM plane (browser → your backend → /v1/embed/responses
+ * with the master key).
+ */
+export function useOpenuiCloudStorage(options: OpenuiCloudOptions): ChatStorage {
+ const { apiBaseUrl, token, fetch, refreshSkewSeconds } = options;
+ const artifactOn = options.features?.artifact ?? true;
+ return useMemo(
+ () =>
+ createCloudStorage({
+ apiBaseUrl,
+ token,
+ fetch,
+ refreshSkewSeconds,
+ features: { artifact: artifactOn },
+ }),
+ [apiBaseUrl, token, fetch, refreshSkewSeconds, artifactOn],
+ );
+}
+
+/** The actual storage wiring — a pure factory with no React, memoised by the
+ * hook above. */
+function createCloudStorage(options: OpenuiCloudOptions): ChatStorage {
+ const tokens = toTokenManager(options);
+ const fctFetch = createFctFetch(tokens, options.fetch);
+ const artifactOn = options.features?.artifact ?? true;
+ const baseUrl = options.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+
+ const storage: ChatStorage = {
+ thread: cloudThreadStorage({ baseUrl, fetch: fctFetch }),
+ };
+ if (artifactOn) {
+ storage.artifact = cloudArtifactStorage({ baseUrl, fetch: fctFetch });
+ }
+ return storage;
+}
+
+/** Normalize the `token` option into a FrontendTokenManager. */
+function toTokenManager(options: OpenuiCloudOptions): FrontendTokenManager {
+ if (typeof options.token === "string") {
+ return createFrontendTokenManager({
+ mintUrl: options.token,
+ fetch: options.fetch,
+ refreshSkewSeconds: options.refreshSkewSeconds,
+ });
+ }
+ const provider = options.token;
+ let current: string | null = null;
+ return {
+ async getToken(): Promise<string> {
+ current = await provider();
+ return current;
+ },
+ invalidate(staleToken?: string): void {
+ if (staleToken === undefined || staleToken === current) current = null;
+ },
+ };
+}
diff --git a/packages/react-headless/src/cloud/threadStorage.ts b/packages/react-headless/src/cloud/threadStorage.ts
new file mode 100644
index 000000000..7a07e2460
--- /dev/null
+++ b/packages/react-headless/src/cloud/threadStorage.ts
@@ -0,0 +1,119 @@
+import type { ThreadStorage } from "../adapters/types";
+import type { Thread } from "../store/types";
+import type { Message, UserMessage } from "../types/message";
+import { cloudItemsToMessages } from "./items";
+import {
+ cloudRequest,
+ nextCursorOf,
+ type CloudConversation,
+ type CloudConversationItem,
+ type CloudListEnvelope,
+} from "./wire";
+
+export interface CloudThreadStorageOptions {
+ /** OpenUI Cloud API origin, e.g. "http://localhost:3102". */
+ baseUrl: string;
+ /** The token-injecting fetch from createFctFetch. */
+ fetch: typeof fetch;
+ /** Page size for list/items calls. */
+ pageLimit?: number;
+}
+
+/** Hard stop for the items pagination loop. */
+const MAX_ITEM_PAGES = 50;
+
+function toThread(conversation: CloudConversation): Thread {
+ return {
+ id: conversation.id,
+ title: conversation.title ?? "New conversation",
+ createdAt: conversation.created_at * 1000, // unix seconds → ms
+ };
+}
+
+/** Client-side title from the first user message (the API does not auto-title). */
+export function deriveTitle(firstMessage: UserMessage): string {
+ const content = firstMessage.content;
+ let text = "";
+ if (typeof content === "string") {
+ text = content;
+ } else if (Array.isArray(content)) {
+ for (const part of content) {
+ if (part.type === "text" && typeof part.text === "string" && part.text.trim() !== "") {
+ text = part.text;
+ break;
+ }
+ }
+ }
+ text = text.trim();
+ return (text === "" ? "New conversation" : text).slice(0, 60);
+}
+
+export function cloudThreadStorage({
+ baseUrl,
+ fetch: fetchImpl,
+ pageLimit = 100,
+}: CloudThreadStorageOptions): ThreadStorage {
+ const request = cloudRequest(fetchImpl, baseUrl);
+
+ return {
+ /** GET /v1/conversations?limit[&after]. Newest-first. */
+ async listThreads(cursor?: string) {
+ const query = new URLSearchParams({ limit: String(pageLimit) });
+ if (cursor !== undefined) query.set("after", cursor);
+ const res = await request(`/v1/conversations?${query.toString()}`);
+ const envelope = (await res.json()) as CloudListEnvelope<CloudConversation>;
+ return {
+ threads: envelope.data.map(toThread),
+ nextCursor: nextCursorOf(envelope),
+ };
+ },
+
+ /** POST /v1/conversations {title}. No messages and no user_id — the user is
+ * bound from the token; the first message arrives later on the generation
+ * plane (conversation linkage). */
+ async createThread(firstMessage: UserMessage): Promise<Thread> {
+ const res = await request(`/v1/conversations`, {
+ method: "POST",
+ body: JSON.stringify({ title: deriveTitle(firstMessage) }),
+ });
+ return toThread((await res.json()) as CloudConversation);
+ },
+
+ /** GET /v1/conversations/:id/items?order=asc, paged, then mapped to Messages. */
+ async getMessages(threadId: string): Promise<Message[]> {
+ const items: CloudConversationItem[] = [];
+ let after: string | undefined;
+ for (let page = 0; page < MAX_ITEM_PAGES; page++) {
+ const query = new URLSearchParams({
+ order: "asc",
+ limit: String(pageLimit),
+ });
+ if (after !== undefined) query.set("after", after);
+ const res = await request(
+ `/v1/conversations/${encodeURIComponent(threadId)}/items?${query.toString()}`,
+ );
+ const envelope = (await res.json()) as CloudListEnvelope<CloudConversationItem>;
+ items.push(...envelope.data);
+ after = nextCursorOf(envelope);
+ if (after === undefined) break;
+ }
+ return cloudItemsToMessages(items);
+ },
+
+ /** POST /v1/conversations/:id {title}. */
+ async updateThread(thread: Thread): Promise<Thread> {
+ const res = await request(`/v1/conversations/${encodeURIComponent(thread.id)}`, {
+ method: "POST",
+ body: JSON.stringify({ title: thread.title }),
+ });
+ return toThread((await res.json()) as CloudConversation);
+ },
+
+ /** DELETE /v1/conversations/:id (soft delete). */
+ async deleteThread(id: string): Promise<void> {
+ await request(`/v1/conversations/${encodeURIComponent(id)}`, {
+ method: "DELETE",
+ });
+ },
+ };
+}
diff --git a/packages/react-headless/src/cloud/wire.ts b/packages/react-headless/src/cloud/wire.ts
new file mode 100644
index 000000000..c008bac6a
--- /dev/null
+++ b/packages/react-headless/src/cloud/wire.ts
@@ -0,0 +1,82 @@
+/**
+ * Wire types for the OpenUI Cloud /v1 API, plus the shared list envelope,
+ * cursor rule, and request helper. Field-for-field mirrors of the API DTOs.
+ */
+
+/** A conversation. `created_at` is unix SECONDS. */
+export interface CloudConversation {
+ id: string;
+ object: "conversation";
+ created_at: number;
+ title?: string;
+ metadata?: Record<string, unknown>;
+ user_id?: string;
+ app_id?: string;
+}
+
+/** A conversation item (full Responses item shape). */
+export interface CloudConversationItem {
+ id: string;
+ object: "conversation.item";
+ type: string; // message | function_call | function_call_output | ...
+ role?: string;
+ status?: string;
+ content?: unknown;
+ metadata?: Record<string, unknown>;
+ created_at: number;
+ call_id?: string;
+ name?: string;
+ arguments?: string;
+ output?: unknown;
+}
+
+/** A stored artifact. `content` is the renderer-ready openui-lang program. */
+export interface CloudArtifact {
+ id: string;
+ object: "openui.artifact";
+ conversation_id: string;
+ kind: string; // 'slides' | 'report'
+ name?: string;
+ version?: string; // server bumps via String(Date.now()) when omitted
+ content: string;
+ created_at: number;
+ updated_at?: number;
+}
+
+/** List envelope shared by all paged endpoints. */
+export interface CloudListEnvelope<T> {
+ object: "list";
+ data: T[];
+ has_more: boolean;
+ first_id?: string;
+ last_id?: string;
+}
+
+/** Forward cursor: pass `last_id` back as `?after=` when there's another page. */
+export function nextCursorOf(envelope: CloudListEnvelope<unknown>): string | undefined {
+ return envelope.has_more && envelope.last_id ? envelope.last_id : undefined;
+}
+
+/**
+ * Request helper: prefix baseUrl, set JSON content-type only when sending a
+ * body, throw on non-2xx. `fetchImpl` is the token-injecting fetch — auth
+ * lives there, never here.
+ */
+export function cloudRequest(fetchImpl: typeof fetch, baseUrl: string) {
+ const base = baseUrl.replace(/\/+$/, "");
+ return async (path: string, init?: RequestInit): Promise<Response> => {
+ const res = await fetchImpl(`${base}${path}`, {
+ ...init,
+ headers: {
+ ...(init?.body ? { "Content-Type": "application/json" } : {}),
+ ...init?.headers,
+ },
+ });
+ if (!res.ok) {
+ throw new Error(
+ `OpenUI Cloud: ${init?.method ?? "GET"} ${path} failed: ${res.status} ${res.statusText}`,
+ );
+ }
+ return res;
+ };
+}
diff --git a/packages/react-headless/src/index.ts b/packages/react-headless/src/index.ts
index 9051cb66b..650221a4d 100644
--- a/packages/react-headless/src/index.ts
+++ b/packages/react-headless/src/index.ts
@@ -1,3 +1,5 @@
+export { useOpenuiCloudStorage } from "./cloud/openuiCloud";
+export type { OpenuiCloudFeatures, OpenuiCloudOptions } from "./cloud/openuiCloud";
export { useActiveDetailedView } from "./hooks/useActiveDetailedView";
export { useArtifactList } from "./hooks/useArtifactList";
export type { ArtifactListFilter } from "./hooks/useArtifactList";
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5b181d8bb..3c9f840f2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -496,21 +496,33 @@ importers:
specifier: 'catalog:'
version: 4.5.7(@types/[email protected])([email protected])
devDependencies:
+ '@types/node':
+ specifier: 'catalog:'
+ version: 22.20.1
'@types/react':
specifier: 'catalog:'
version: 19.2.17
+ '@types/react-dom':
+ specifier: 'catalog:'
+ version: 19.2.3(@types/[email protected])
ai:
specifier: ^6.0.236
version: 6.0.236([email protected])
eve:
specifier: ^0.11.7
+ jsdom:
+ specifier: 'catalog:'
+ version: 26.1.0
openai:
specifier: ^6.22.0
+ react-dom:
+ specifier: 'catalog:'
+ version: 19.2.4([email protected])
vitest:
specifier: ^4.1.0
packages/react-lang:
dependencies:
@@ -16638,16 +16650,16 @@ snapshots:
dependencies:
ai: 6.0.236([email protected])
optionalDependencies:
'@opentelemetry/api': 1.9.1
react: 19.2.4
svelte: 5.56.8(@typescript-eslint/[email protected])
vue: 3.5.40([email protected])
transitivePeerDependencies:
- '@azure/app-configuration'
@@ -18510,7 +18522,7 @@ snapshots:
dependencies:
consola: 3.4.2
crossws: 0.4.12([email protected])
@@ -18530,7 +18542,7 @@ snapshots:
dotenv: 17.4.2
jiti: 2.7.0
rollup: 4.62.3
transitivePeerDependencies:
- '@azure/app-configuration'
- '@azure/cosmos'