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.mdnew file mode 100644index 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.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.yamlindex 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.236version: 6.0.236([email protected])eve:specifier: ^0.11.7- version: 0.11.10(@opentelemetry/[email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@opentelemetry/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected]))([email protected])([email protected])([email protected](@typescript-eslint/[email protected]))([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))([email protected]([email protected]))+ version: 0.11.10(@opentelemetry/[email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@opentelemetry/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected]))([email protected])([email protected])([email protected](@typescript-eslint/[email protected]))([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))([email protected]([email protected]))+ jsdom:+ specifier: 'catalog:'+ version: 26.1.0openai:specifier: ^6.22.0version: 6.49.0(@aws-sdk/[email protected])(@smithy/[email protected])([email protected])([email protected])+ react-dom:+ specifier: 'catalog:'+ version: 19.2.4([email protected])vitest:specifier: ^4.1.0- version: 4.1.10(@opentelemetry/[email protected])(@types/[email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))+ version: 4.1.10(@opentelemetry/[email protected])(@types/[email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))packages/react-lang:dependencies:@@ -16638,16 +16650,16 @@ snapshots:- [email protected](@opentelemetry/[email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@opentelemetry/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected]))([email protected])([email protected])([email protected](@typescript-eslint/[email protected]))([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))([email protected]([email protected])):+ [email protected](@opentelemetry/[email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@opentelemetry/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected]))([email protected])([email protected])([email protected](@typescript-eslint/[email protected]))([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))([email protected]([email protected])):dependencies:ai: 6.0.236([email protected])- nitro: 3.0.260610-beta([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))+ nitro: 3.0.260610-beta([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected]))optionalDependencies:'@opentelemetry/api': 1.9.1next: 16.2.6(@opentelemetry/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected])react: 19.2.4svelte: 5.56.8(@typescript-eslint/[email protected])- vite: 7.3.6(@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])+ vite: 7.3.6(@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])vue: 3.5.40([email protected])transitivePeerDependencies:- '@azure/app-configuration'@@ -18510,7 +18522,7 @@ snapshots:- [email protected]([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])):+ [email protected]([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])):dependencies:consola: 3.4.2crossws: 0.4.12([email protected])@@ -18530,7 +18542,7 @@ snapshots:dotenv: 17.4.2jiti: 2.7.0rollup: 4.62.3- vite: 7.3.6(@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])+ vite: 7.3.6(@types/[email protected])([email protected])([email protected])([email protected])([email protected])([email protected])([email protected])transitivePeerDependencies:- '@azure/app-configuration'- '@azure/cosmos'