Skip to content

The Open Standard for Generative UI

Devtools: add streaming logs for OpenUI Renderer (#926)

abhithesysd41b5932d13c
diff --git a/packages/devtools/package.json b/packages/devtools/package.json
index 76f10e4ce..7a478b70b 100644
--- a/packages/devtools/package.json
+++ b/packages/devtools/package.json
@@ -1,6 +1,6 @@
{
"name": "@openuidev/devtools",
- "version": "0.0.2",
+ "version": "0.0.3",
"description": "Development-only UI widget for OpenUI apps: surfaces errors captured by @openuidev/observability",
"license": "MIT",
"type": "module",
diff --git a/packages/devtools/src/OpenUIDevtools.test.ts b/packages/devtools/src/OpenUIDevtools.test.ts
index 5d790d02a..9c12fd36c 100644
--- a/packages/devtools/src/OpenUIDevtools.test.ts
+++ b/packages/devtools/src/OpenUIDevtools.test.ts
@@ -84,12 +84,37 @@ describe("OpenUIDevtools", () => {
it("filters out info events when errorsOnly is set", () => {
render({ enabled: true, errorsOnly: true });
act(() => observability.info({ kind: "just-info" }));
+ act(() => observability.warn({ kind: "useful-warning" }));
act(() => observability.error({ kind: "real-error" }));
expect(container.textContent).not.toContain("just-info");
+ expect(container.textContent).toContain("useful-warning");
expect(container.textContent).toContain("real-error");
});
+ it("coalesces successive snapshots of any event with a stable id", () => {
+ render({ enabled: true, errorsOnly: false });
+
+ act(() =>
+ observability.info({
+ id: "job-1",
+ kind: "job:progress",
+ message: "Starting",
+ }),
+ );
+ act(() =>
+ observability.warn({
+ id: "job-1",
+ kind: "job:progress",
+ message: "Needs attention",
+ }),
+ );
+
+ expect(container.textContent?.match(/job:progress/g)).toHaveLength(1);
+ expect(container.textContent).not.toContain("Starting");
+ expect(container.textContent).toContain("Needs attention");
+ });
+
it("drills into the stack trace when a row's Stack Trace is clicked", () => {
render({ enabled: true, errorsOnly: false });
act(() => observability.error({ kind: "boom", error: toErrorInfo(new Error("kaboom")) }));
@@ -100,4 +125,184 @@ describe("OpenUIDevtools", () => {
expect(container.textContent).toContain("stack trace");
});
+
+ it("coalesces react-lang stream updates by their stable event id", () => {
+ render({ enabled: true, errorsOnly: false });
+
+ act(() =>
+ observability.info({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 1,
+ response: "root = Car",
+ parser: { statementCount: 1, orphaned: [] },
+ }),
+ );
+ act(() =>
+ observability.info({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 2,
+ response: 'root = Card("done")',
+ parser: { statementCount: 2, orphaned: ["unused"] },
+ }),
+ );
+
+ expect(container.textContent?.match(/OpenUI Lang stream/g)).toHaveLength(1);
+ expect(container.textContent).toContain("info");
+ expect(container.textContent).toContain("Streaming");
+ expect(container.textContent).toContain("2 statements");
+ expect(container.textContent).toContain("1 orphaned statement");
+ expect(container.textContent).not.toContain("stream-1");
+ expect(container.textContent).not.toContain('root = Card("done")');
+
+ const expand = container.querySelector<HTMLButtonElement>(
+ 'button[aria-label="Toggle OpenUI Lang stream details"]',
+ );
+ expect(expand).not.toBeNull();
+ click(expand!);
+
+ expect(container.textContent).toContain('root = Card("done")');
+ expect(container.textContent).toContain("Orphaned: unused");
+ });
+
+ it("replaces a stream update with its settled diagnostics", () => {
+ render({ enabled: true, errorsOnly: false });
+
+ act(() =>
+ observability.info({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 1,
+ response: "root = Ghost()",
+ }),
+ );
+ act(() =>
+ observability.error({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "settled",
+ updateIndex: 1,
+ response: "root = Ghost()",
+ parser: { statementCount: 1, orphaned: [] },
+ errors: [
+ {
+ source: "parser",
+ code: "unknown-component",
+ message: "Unknown component Ghost",
+ component: "Ghost",
+ statementId: "root",
+ hint: "Use a component registered in the library",
+ },
+ ],
+ }),
+ );
+
+ expect(container.textContent?.match(/OpenUI Lang stream/g)).toHaveLength(1);
+ expect(container.textContent).not.toContain("settled");
+ expect(container.textContent).not.toContain("Streaming");
+ expect(container.textContent).toContain("1 statement");
+ expect(container.textContent).toContain("1 error");
+ expect(container.textContent).not.toContain("Unknown component Ghost");
+
+ const expand = container.querySelector<HTMLButtonElement>(
+ 'button[aria-label="Toggle OpenUI Lang stream details"]',
+ );
+ expect(expand).not.toBeNull();
+ click(expand!);
+
+ expect(container.textContent).toContain("parser / unknown-component");
+ expect(container.textContent).toContain("Unknown component Ghost");
+ expect(container.textContent).toContain("Use a component registered in the library");
+ expect(container.textContent).toContain("root = Ghost()");
+ expect(toggle().textContent).toContain("1");
+ });
+
+ it("hides provisional errors while the stream is still running", () => {
+ render({ enabled: true, errorsOnly: false });
+
+ act(() =>
+ observability.info({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "streaming",
+ response: "root = Ghost()",
+ errors: [{ source: "parser", code: "unknown-component", message: "Transient error" }],
+ parser: { statementCount: 1, orphaned: ["draft"] },
+ }),
+ );
+
+ const expand = container.querySelector<HTMLButtonElement>(
+ 'button[aria-label="Toggle OpenUI Lang stream details"]',
+ );
+ click(expand!);
+
+ expect(container.textContent).not.toContain("Transient error");
+ expect(container.textContent).toContain("root = Ghost()");
+ expect(container.textContent).toContain("Orphaned: draft");
+ });
+
+ it("keeps an expanded stream open when a settled error snapshot is refreshed", () => {
+ render({ enabled: true, errorsOnly: false });
+
+ act(() =>
+ observability.error({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "settled",
+ response: "root = First()",
+ errors: [{ source: "parser", code: "first-error", message: "First error" }],
+ }),
+ );
+
+ const expand = container.querySelector<HTMLButtonElement>(
+ 'button[aria-label="Toggle OpenUI Lang stream details"]',
+ );
+ click(expand!);
+ expect(container.textContent).toContain("First error");
+
+ act(() =>
+ observability.error({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "settled",
+ response: "root = Second()",
+ errors: [{ source: "query", code: "query-error", message: "Second error" }],
+ }),
+ );
+
+ expect(container.textContent?.match(/OpenUI Lang stream/g)).toHaveLength(1);
+ expect(container.textContent).not.toContain("First error");
+ expect(container.textContent).toContain("Second error");
+ expect(container.textContent).toContain("root = Second()");
+ });
+
+ it("removes a resolved stream from the errors-only view", () => {
+ render({ enabled: true, errorsOnly: true, autoOpenOnError: false });
+
+ act(() =>
+ observability.error({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "settled",
+ errors: [{ source: "query", code: "query-error", message: "Query failed" }],
+ }),
+ );
+ expect(container.textContent).toContain("OpenUI Lang stream");
+
+ act(() =>
+ observability.info({
+ kind: "react-lang:stream",
+ id: "stream-1",
+ phase: "settled",
+ errors: [],
+ }),
+ );
+
+ expect(container.textContent).not.toContain("OpenUI Lang stream");
+ expect(container.textContent).toContain("No events captured yet.");
+ });
});
diff --git a/packages/devtools/src/OpenUIDevtools.tsx b/packages/devtools/src/OpenUIDevtools.tsx
index c69410ced..83df5f0fb 100644
--- a/packages/devtools/src/OpenUIDevtools.tsx
+++ b/packages/devtools/src/OpenUIDevtools.tsx
@@ -7,7 +7,9 @@ import {
} from "@openuidev/observability";
import { ArrowLeft, Check, Copy, CreditCard, WrapText, X } from "lucide-react";
import { useEffect, useRef, useState, type CSSProperties } from "react";
+import { getReactLangStreamDetail, ReactLangStreamEventRow } from "./ReactLangStreamEventRow";
import { ShiroLogo } from "./ShiroLogo";
+import { addOrReplaceEvent } from "./eventBuffer";
export type DevtoolsPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
@@ -18,7 +20,7 @@ export interface OpenUIDevtoolsProps {
position?: DevtoolsPosition;
/** How many events to keep; oldest are dropped first. */
maxEvents?: number;
- /** Initial state of the drawer's "errors only" capture filter: only
+ /** Initial state of the drawer's "errors only" display filter: only
* error/warning events (default) or every event. */
errorsOnly?: boolean;
/** Initial state of the drawer's "auto-open on error" checkbox. Defaults to true. */
@@ -36,7 +38,7 @@ export function OpenUIDevtools({
enabled,
position = "bottom-right",
maxEvents = 50,
- errorsOnly = true,
+ errorsOnly = false,
autoOpenOnError = true,
}: OpenUIDevtoolsProps) {
const isEnabled =
@@ -52,14 +54,11 @@ export function OpenUIDevtools({
// Read the live checkbox values inside the (stable) subscription without re-subscribing.
const autoOpenRef = useRef(autoOpen);
autoOpenRef.current = autoOpen;
- const onlyErrorsRef = useRef(onlyErrors);
- onlyErrorsRef.current = onlyErrors;
useEffect(() => {
if (!isEnabled) return;
return observability.listenAll((event) => {
- if (onlyErrorsRef.current && event.level === "info") return;
- setEvents((prev) => [event, ...prev].slice(0, maxEvents));
+ setEvents((prev) => addOrReplaceEvent(prev, event, maxEvents));
if (event.level === "error" && autoOpenRef.current) setOpen(true);
});
}, [isEnabled, maxEvents]);
@@ -79,6 +78,7 @@ export function OpenUIDevtools({
if (!isEnabled) return null;
const errorCount = events.filter((event) => event.level === "error").length;
+ const visibleEvents = onlyErrors ? events.filter((event) => event.level !== "info") : events;
const openDrawer = () => {
setSelected(null);
@@ -210,12 +210,19 @@ export function OpenUIDevtools({
</label>
</div>
<div style={styles.list}>
- {events.length === 0 ? (
+ {visibleEvents.length === 0 ? (
<div style={styles.empty}>No events captured yet.</div>
) : (
- events.map((event, index) => {
- const key = `${event.timestamp}-${index}`;
+ visibleEvents.map((event, index) => {
+ const key =
+ typeof event.detail["id"] === "string"
+ ? event.detail["id"]
+ : `${event.timestamp}-${index}`;
if (isCreditsExhausted(event)) return <CreditsEventRow key={key} />;
+ const stream = getReactLangStreamDetail(event);
+ if (stream) {
+ return <ReactLangStreamEventRow key={key} event={event} stream={stream} />;
+ }
const error = getErrorInfo(event);
const detail = asRecord(event.detail);
diff --git a/packages/devtools/src/ReactLangStreamEventRow.tsx b/packages/devtools/src/ReactLangStreamEventRow.tsx
new file mode 100644
index 000000000..50f234b05
--- /dev/null
+++ b/packages/devtools/src/ReactLangStreamEventRow.tsx
@@ -0,0 +1,365 @@
+import { type ObservabilityEvent } from "@openuidev/observability";
+import { Check, ChevronDown, ChevronRight, Copy } from "lucide-react";
+import { useState, type CSSProperties } from "react";
+
+export interface ReactLangStreamDetail {
+ phase: "streaming" | "settled";
+ response?: string;
+ errors: Record<string, unknown>[];
+ parser?: {
+ incomplete?: boolean;
+ unresolved?: string[];
+ orphaned?: string[];
+ statementCount?: number;
+ };
+}
+
+export function getReactLangStreamDetail(event: ObservabilityEvent): ReactLangStreamDetail | null {
+ const detail = asRecord(event.detail);
+ if (
+ detail["kind"] !== "react-lang:stream" ||
+ (detail["phase"] !== "streaming" && detail["phase"] !== "settled")
+ ) {
+ return null;
+ }
+
+ const parser = asRecord(detail["parser"]);
+ return {
+ phase: detail["phase"],
+ response: asString(detail["response"]),
+ errors: Array.isArray(detail["errors"]) ? detail["errors"].map((error) => asRecord(error)) : [],
+ parser:
+ Object.keys(parser).length > 0
+ ? {
+ incomplete:
+ typeof parser["incomplete"] === "boolean" ? parser["incomplete"] : undefined,
+ unresolved: Array.isArray(parser["unresolved"])
+ ? parser["unresolved"].filter((value): value is string => typeof value === "string")
+ : undefined,
+ orphaned: Array.isArray(parser["orphaned"])
+ ? parser["orphaned"].filter((value): value is string => typeof value === "string")
+ : undefined,
+ statementCount:
+ typeof parser["statementCount"] === "number" ? parser["statementCount"] : undefined,
+ }
+ : undefined,
+ };
+}
+
+export function ReactLangStreamEventRow({
+ event,
+ stream,
+}: {
+ event: ObservabilityEvent;
+ stream: ReactLangStreamDetail;
+}) {
+ const [expanded, setExpanded] = useState(false);
+ const [responseCopied, setResponseCopied] = useState(false);
+ const isStreaming = stream.phase === "streaming";
+ const visibleErrors = isStreaming ? [] : stream.errors;
+ const statementCount = stream.parser?.statementCount;
+ const orphaned = stream.parser?.orphaned ?? [];
+ const parserIssues = [
+ !isStreaming && stream.parser?.incomplete ? "Incomplete input" : null,
+ !isStreaming && stream.parser?.unresolved?.length
+ ? `Unresolved: ${stream.parser.unresolved.join(", ")}`
+ : null,
+ orphaned.length > 0 ? `Orphaned: ${orphaned.join(", ")}` : null,
+ ].filter((issue): issue is string => Boolean(issue));
+
+ const copyResponse = () => {
+ if (typeof navigator === "undefined" || !navigator.clipboard || !stream.response) return;
+ navigator.clipboard
+ .writeText(stream.response)
+ .then(() => {
+ setResponseCopied(true);
+ setTimeout(() => setResponseCopied(false), 1500);
+ })
+ .catch(() => {});
+ };
+
+ return (
+ <div style={styles.row}>
+ <button
+ type="button"
+ style={styles.streamToggle}
+ onClick={() => setExpanded((current) => !current)}
+ aria-expanded={expanded}
+ aria-label="Toggle OpenUI Lang stream details"
+ >
+ <div style={styles.rowHeader}>
+ <div style={styles.badgeGroup}>
+ {expanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
+ <span style={{ ...styles.badge, ...badgeByLevel[event.level] }}>{event.level}</span>
+ <span style={{ ...styles.badge, ...styles.badgeNeutral }}>OpenUI Lang stream</span>
+ {isStreaming ? (
+ <span style={{ ...styles.badge, ...styles.badgeStreaming }}>Streaming</span>
+ ) : null}
+ </div>
+ <span style={styles.time}>{new Date(event.timestamp).toLocaleTimeString()}</span>
+ </div>
+ <div style={styles.streamOverview}>
+ {statementCount !== undefined ? (
+ <span>
+ {statementCount} statement{statementCount === 1 ? "" : "s"}
+ </span>
+ ) : null}
+ {orphaned.length > 0 ? (
+ <span>
+ {orphaned.length} orphaned statement{orphaned.length === 1 ? "" : "s"}
+ </span>
+ ) : null}
+ {visibleErrors.length > 0 ? (
+ <span style={styles.errorSummary}>
+ {visibleErrors.length} error{visibleErrors.length === 1 ? "" : "s"}
+ </span>
+ ) : null}
+ </div>
+ </button>
+
+ {expanded ? (
+ <div style={styles.streamExpanded}>
+ {visibleErrors.length > 0 ? (
+ <section style={styles.streamSection}>
+ <div style={styles.streamSectionTitle}>Errors ({visibleErrors.length})</div>
+ <div style={styles.diagnosticList}>
+ {visibleErrors.map((error, index) => (
+ <Diagnostic
+ key={`${asString(error["source"]) ?? "error"}-${asString(error["code"]) ?? "unknown"}-${index}`}
+ error={error}
+ />
+ ))}
+ </div>
+ </section>
+ ) : null}
+
+ {parserIssues.length > 0 ? (
+ <section style={styles.streamSection}>
+ <div style={styles.streamSectionTitle}>Parser details</div>
+ <div style={styles.parserIssues}>{parserIssues.join(" · ")}</div>
+ </section>
+ ) : null}
+
+ <section style={styles.streamSection}>
+ <div style={styles.responseHeader}>
+ <div style={styles.streamSectionTitle}>Response</div>
+ <button type="button" style={styles.copyResponseButton} onClick={copyResponse}>
+ {responseCopied ? <Check size={12} /> : <Copy size={12} />}
+ {responseCopied ? "Copied" : "Copy"}
+ </button>
+ </div>
+ <pre style={styles.responseCode}>{stream.response || "(empty response)"}</pre>
+ </section>
+ </div>
+ ) : null}
+ </div>
+ );
+}
+
+function Diagnostic({ error }: { error: Record<string, unknown> }) {
+ const source = asString(error["source"]);
+ const code = asString(error["code"]);
+ const message = asString(error["message"]) ?? "Unknown OpenUI Lang error";
+ const location = [
+ asString(error["component"]),
+ asString(error["statementId"]),
+ asString(error["path"]),
+ ].filter(Boolean);
+ const hint = asString(error["hint"]);
+
+ return (
+ <div style={styles.diagnostic}>
+ <div style={styles.diagnosticHeader}>
+ {[source, code].filter(Boolean).join(" / ") || "error"}
+ </div>
+ <div>{message}</div>
+ {location.length > 0 ? (
+ <div style={styles.diagnosticLocation}>{location.join(" · ")}</div>
+ ) : null}
+ {hint ? <div style={styles.diagnosticHint}>{hint}</div> : null}
+ </div>
+ );
+}
+
+function asRecord(detail: unknown): Record<string, unknown> {
+ return typeof detail === "object" && detail !== null ? (detail as Record<string, unknown>) : {};
+}
+
+function asString(value: unknown): string | undefined {
+ return typeof value === "string" ? value : undefined;
+}
+
+const FONT = '"Inter", system-ui, sans-serif';
+const MONO = "ui-monospace, SFMono-Regular, Menlo, monospace";
+
+const badgeByLevel: Record<ObservabilityEvent["level"], CSSProperties> = {
+ error: { background: "#fef2f2", color: "#b91c1c", borderColor: "#fecaca" },
+ warning: { background: "#fffbeb", color: "#b45309", borderColor: "#fde68a" },
+ info: { background: "#eff6ff", color: "#1d4ed8", borderColor: "#bfdbfe" },
+};
+
+const styles = {
+ row: {
+ border: "1px solid #e4e4e7",
+ borderRadius: 12,
+ padding: 12,
+ display: "flex",
+ flexDirection: "column",
+ gap: 6,
+ background: "#ffffff",
+ boxShadow: "0 1px 2px rgba(24, 24, 27, 0.04)",
+ },
+ rowHeader: {
+ display: "flex",
+ justifyContent: "space-between",
+ alignItems: "center",
+ gap: 8,
+ },
+ badgeGroup: {
+ display: "flex",
+ alignItems: "center",
+ flexWrap: "wrap",
+ gap: 6,
+ minWidth: 0,
+ },
+ badge: {
+ display: "inline-flex",
+ alignItems: "center",
+ borderRadius: 999,
+ borderWidth: 1,
+ borderStyle: "solid",
+ borderColor: "transparent",
+ padding: "1px 8px",
+ fontSize: 11,
+ fontWeight: 500,
+ fontFamily: FONT,
+ },
+ badgeNeutral: {
+ background: "#f4f4f5",
+ color: "#52525b",
+ borderColor: "#e4e4e7",
+ fontFamily: MONO,
+ },
+ badgeStreaming: {
+ background: "#ecfdf5",
+ color: "#047857",
+ borderColor: "#a7f3d0",
+ },
+ time: {
+ color: "#a1a1aa",
+ fontSize: 11,
+ },
+ streamToggle: {
+ width: "100%",
+ border: "none",
+ background: "transparent",
+ color: "inherit",
+ cursor: "pointer",
+ fontFamily: FONT,
+ padding: 0,
+ textAlign: "left",
+ },
+ streamOverview: {
+ display: "flex",
+ flexWrap: "wrap",
+ gap: "4px 10px",
+ color: "#71717a",
+ fontSize: 11,
+ marginTop: 7,
+ paddingLeft: 20,
+ },
+ errorSummary: {
+ color: "#b91c1c",
+ fontWeight: 600,
+ },
+ streamExpanded: {
+ display: "flex",
+ flexDirection: "column",
+ gap: 14,
+ borderTop: "1px solid #f4f4f5",
+ marginTop: 4,
+ paddingTop: 12,
+ },
+ streamSection: {
+ display: "flex",
+ flexDirection: "column",
+ gap: 6,
+ },
+ streamSectionTitle: {
+ color: "#52525b",
+ fontSize: 11,
+ fontWeight: 600,
+ textTransform: "uppercase",
+ letterSpacing: "0.04em",
+ },
+ responseHeader: {
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "space-between",
+ gap: 8,
+ },
+ copyResponseButton: {
+ display: "inline-flex",
+ alignItems: "center",
+ gap: 4,
+ border: "none",
+ background: "transparent",
+ color: "#52525b",
+ cursor: "pointer",
+ fontFamily: FONT,
+ fontSize: 11,
+ padding: 0,
+ },
+ responseCode: {
+ maxHeight: 260,
+ overflow: "auto",
+ margin: 0,
+ border: "1px solid #e4e4e7",
+ borderRadius: 8,
+ background: "#fafafa",
+ color: "#27272a",
+ fontFamily: MONO,
+ fontSize: 11,
+ lineHeight: 1.5,
+ padding: 10,
+ whiteSpace: "pre-wrap",
+ wordBreak: "break-word",
+ },
+ parserIssues: {
+ borderRadius: 8,
+ background: "#fffbeb",
+ color: "#92400e",
+ fontSize: 11,
+ lineHeight: 1.45,
+ padding: "6px 8px",
+ },
+ diagnosticList: {
+ display: "flex",
+ flexDirection: "column",
+ gap: 6,
+ },
+ diagnostic: {
+ borderLeft: "2px solid #fca5a5",
+ background: "#fef2f2",
+ color: "#3f3f46",
+ fontSize: 11,
+ lineHeight: 1.45,
+ padding: "7px 8px",
+ },
+ diagnosticHeader: {
+ color: "#991b1b",
+ fontFamily: MONO,
+ fontWeight: 600,
+ marginBottom: 3,
+ },
+ diagnosticLocation: {
+ color: "#71717a",
+ fontFamily: MONO,
+ marginTop: 3,
+ },
+ diagnosticHint: {
+ color: "#52525b",
+ fontStyle: "italic",
+ marginTop: 4,
+ },
+} satisfies Record<string, CSSProperties>;
diff --git a/packages/devtools/src/eventBuffer.ts b/packages/devtools/src/eventBuffer.ts
new file mode 100644
index 000000000..180804820
--- /dev/null
+++ b/packages/devtools/src/eventBuffer.ts
@@ -0,0 +1,16 @@
+import type { ObservabilityEvent } from "@openuidev/observability";
+
+export function addOrReplaceEvent(
+ events: ObservabilityEvent[],
+ event: ObservabilityEvent,
+ maxEvents: number,
+): ObservabilityEvent[] {
+ const id = stableEventId(event);
+ const remaining =
+ id === null ? events : events.filter((existing) => stableEventId(existing) !== id);
+ return [event, ...remaining].slice(0, maxEvents);
+}
+
+function stableEventId(event: ObservabilityEvent): string | null {
+ return typeof event.detail["id"] === "string" ? event.detail["id"] : null;
+}
diff --git a/packages/observability/README.md b/packages/observability/README.md
index 385152ae5..c87dbd749 100644
--- a/packages/observability/README.md
+++ b/packages/observability/README.md
@@ -36,6 +36,9 @@ observability("error", { kind: "renderer:error", component: "Chart", error: toEr
observability.error({ kind: "llm:timeout", requestId, message: "timed out" });
observability.warn({ kind: "chart:overflow", component: "Chart", points: 1200 });
observability.info({ kind: "route:change", to: "/settings" });
+
+// Reuse an id when publishing successive snapshots of one logical event.
+observability.info({ id: streamId, kind: "llm:stream", response });
```
## The event envelope
@@ -56,6 +59,7 @@ interface ObservabilityEvent {
```ts
interface ObservabilityDetail {
+ id?: string; // stable identity shared by successive snapshots
kind: string; // required descriptor, e.g. "fetch:error"
message?: string; // optional human-readable message
error?: ObservabilityErrorInfo; // present on failures; build with toErrorInfo()
diff --git a/packages/observability/package.json b/packages/observability/package.json
index 0a896a766..a2655ecef 100644
--- a/packages/observability/package.json
+++ b/packages/observability/package.json
@@ -1,6 +1,6 @@
{
"name": "@openuidev/observability",
- "version": "0.0.1",
+ "version": "0.0.2",
"description": "Framework-free observability event bus for OpenUI: emit and listen to events",
"license": "MIT",
"type": "module",
diff --git a/packages/observability/src/observability.test.ts b/packages/observability/src/observability.test.ts
index 937996a54..aeeabc330 100644
--- a/packages/observability/src/observability.test.ts
+++ b/packages/observability/src/observability.test.ts
@@ -99,6 +99,15 @@ describe("observability bus", () => {
expect(received?.detail).toMatchObject({ kind: "shape", extra: 1 });
});
+ it("preserves an optional stable event id in the detail", () => {
+ let received: ObservabilityEvent | undefined;
+ track(observability.listenAll((event) => (received = event)));
+
+ observability.info({ id: "event-1", kind: "stream:update" });
+
+ expect(received?.detail.id).toBe("event-1");
+ });
+
it("a throwing listener does not break the others", () => {
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
const good = vi.fn();
diff --git a/packages/observability/src/types.ts b/packages/observability/src/types.ts
index d981bf2dc..b4b57c0cb 100644
--- a/packages/observability/src/types.ts
+++ b/packages/observability/src/types.ts
@@ -48,6 +48,11 @@ export type ObservabilityLevel = "info" | "warning" | "error";
* top-level type); everything else is optional or free extra fields.
*/
export interface ObservabilityDetail {
+ /**
+ * Stable identity for successive snapshots of one logical event. Consumers
+ * may replace an earlier snapshot when another event uses the same id.
+ */
+ id?: string;
/** Short descriptor of what happened, e.g. "fetch:error", "route:change". */
kind: string;
/** Optional human-readable message. */
diff --git a/packages/react-lang/package.json b/packages/react-lang/package.json
index 1f14ab84d..5ba24c84a 100644
--- a/packages/react-lang/package.json
+++ b/packages/react-lang/package.json
@@ -1,6 +1,6 @@
{
"name": "@openuidev/react-lang",
- "version": "0.2.9",
+ "version": "0.2.10",
"description": "Define component libraries, generate LLM system prompts, and render streaming OpenUI Lang output in React — the core runtime for OpenUI generative UI",
"license": "MIT",
"type": "module",
@@ -66,7 +66,8 @@
},
"author": "[email protected]",
"dependencies": {
- "@openuidev/lang-core": "workspace:^"
+ "@openuidev/lang-core": "workspace:^",
+ "@openuidev/observability": "workspace:^"
},
"peerDependencies": {
"@modelcontextprotocol/sdk": ">=1.0.0",
@@ -81,6 +82,9 @@
"devDependencies": {
"@modelcontextprotocol/sdk": "^1.27.1",
"@types/react": "catalog:",
+ "@types/react-dom": "catalog:",
+ "jsdom": "catalog:",
+ "react-dom": "catalog:",
"vitest": "^4.0.18"
}
}
diff --git a/packages/react-lang/src/hooks/useOpenUIErrors.ts b/packages/react-lang/src/hooks/useOpenUIErrors.ts
new file mode 100644
index 000000000..e51052663
--- /dev/null
+++ b/packages/react-lang/src/hooks/useOpenUIErrors.ts
@@ -0,0 +1,120 @@
+import {
+ enrichErrors,
+ type OpenUIError,
+ type ParseResult,
+ type QuerySnapshot,
+} from "@openuidev/lang-core";
+import { useEffect, useRef, useState } from "react";
+import type { Library } from "../library";
+
+type CurrentRef<T> = { current: T };
+
+export interface OpenUIErrorsResult {
+ errorsRef: CurrentRef<OpenUIError[]>;
+ errorRevision: number;
+}
+
+export interface UseOpenUIErrorsOptions {
+ response: string | null;
+ isStreaming: boolean;
+ result: ParseResult | null;
+ evaluatedResult: ParseResult | null;
+ library: Library;
+ querySnapshot: QuerySnapshot;
+ parseExceptionRef: CurrentRef<OpenUIError | null>;
+ runtimeErrorsRef: CurrentRef<OpenUIError[]>;
+ renderErrorsRef: CurrentRef<OpenUIError[]>;
+ onError?: (errors: OpenUIError[]) => void;
+}
+
+/** Aggregates Renderer errors and owns the public onError callback behavior. */
+export function useOpenUIErrors({
+ response,
+ isStreaming,
+ result,
+ evaluatedResult,
+ library,
+ querySnapshot,
+ parseExceptionRef,
+ runtimeErrorsRef,
+ renderErrorsRef,
+ onError,
+}: UseOpenUIErrorsOptions): OpenUIErrorsResult {
+ const errorsRef = useRef<OpenUIError[]>([]);
+ const [errorRevision, setErrorRevision] = useState(0);
+ const lastErrorKeyRef = useRef("");
+ const onErrorRef = useRef(onError);
+ onErrorRef.current = onError;
+
+ useEffect(() => {
+ if (isStreaming) {
+ errorsRef.current = [];
+
+ // Clear stale errors so correction-loop consumers receive a clean signal
+ // while the next response is being generated.
+ if (lastErrorKeyRef.current !== "") {
+ lastErrorKeyRef.current = "";
+ onErrorRef.current?.([]);
+ }
+ return;
+ }
+
+ const errors: OpenUIError[] = [];
+
+ if (parseExceptionRef.current) {
+ errors.push(parseExceptionRef.current);
+ }
+
+ if (response && !result?.root && !parseExceptionRef.current) {
+ errors.push({
+ source: "parser",
+ code: "parse-failed",
+ message: result
+ ? "Code parsed but produced no renderable root component"
+ : "Response could not be parsed as valid openui-lang",
+ hint: `The entire response must be valid openui-lang code starting with root = ${library.root ?? "Root"}(...)`,
+ });
+ }
+
+ if (result?.meta.errors.length) {
+ errors.push(
+ ...enrichErrors(
+ result.meta.errors,
+ library.toJSONSchema(),
+ Object.keys(library.components),
+ ),
+ );
+ }
+
+ errors.push(...runtimeErrorsRef.current);
+ errors.push(...renderErrorsRef.current);
+ renderErrorsRef.current = [];
+ errors.push(...(querySnapshot.__openui_errors ?? []));
+ errorsRef.current = errors;
+
+ const errorKey = JSON.stringify(errors);
+ if (errorKey === lastErrorKeyRef.current) return;
+
+ lastErrorKeyRef.current = errorKey;
+ setErrorRevision((revision) => revision + 1);
+ if (onErrorRef.current) {
+ onErrorRef.current(errors);
+ } else if (errors.length > 0) {
+ for (const error of errors) {
+ console.warn(`[openui] ${error.source}/${error.code}: ${error.message}`);
+ }
+ }
+ }, [
+ isStreaming,
+ response,
+ result,
+ evaluatedResult,
+ querySnapshot,
+ library,
+ parseExceptionRef,
+ runtimeErrorsRef,
+ renderErrorsRef,
+ ]);
+
+ return { errorsRef, errorRevision };
+}
diff --git a/packages/react-lang/src/hooks/useOpenUIState.ts b/packages/react-lang/src/hooks/useOpenUIState.ts
index 987008fe0..899e38826 100644
--- a/packages/react-lang/src/hooks/useOpenUIState.ts
+++ b/packages/react-lang/src/hooks/useOpenUIState.ts
@@ -4,7 +4,6 @@ import {
createQueryManager,
createStore,
createStreamingParser,
- enrichErrors,
evaluate,
evaluateElementProps,
type ActionEvent,
@@ -22,6 +21,8 @@ import type React from "react";
import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
import type { OpenUIContextValue } from "../context";
import type { Library } from "../library";
+import { useOpenUIErrors } from "./useOpenUIErrors";
+import { useStreamingObservability } from "./useStreamingObservability";
/** Unwrap { value, componentType } wrapper from form field entries. Returns raw value. */
function unwrapFieldValue(v: unknown): unknown {
@@ -202,8 +203,8 @@ export function useOpenUIState(
}, [isStreaming, result?.mutationStatements, evaluationContext, queryManager]);
// ─── Ref for stable callbacks ───
- const propsRef = useRef({ onAction, onStateUpdate, onError });
- propsRef.current = { onAction, onStateUpdate, onError };
+ const propsRef = useRef({ onAction, onStateUpdate });
+ propsRef.current = { onAction, onStateUpdate };
const resultRef = useRef(result);
resultRef.current = result;
@@ -436,72 +437,22 @@ export function useOpenUIState(
}
}, [result, evaluationContext, library, store, storeSnapshot, querySnapshot]);
- // ─── Collect and fire onError ───
- const lastErrorKeyRef = useRef<string>("");
- useEffect(() => {
- if (isStreaming) {
- // Clear stale errors from previous session so the correction loop
- // gets a clean signal when this streaming session completes.
- if (lastErrorKeyRef.current !== "") {
- lastErrorKeyRef.current = "";
- propsRef.current.onError?.([]);
- }
- return;
- }
- const errors: OpenUIError[] = [];
-
- // Parser exception (parser itself crashed)
- if (parseExceptionRef.current) {
- errors.push(parseExceptionRef.current);
- }
-
- // Parse failure — response exists but produced no renderable root
- if (response && !result?.root && !parseExceptionRef.current) {
- errors.push({
- source: "parser",
- code: "parse-failed",
- message: result
- ? "Code parsed but produced no renderable root component"
- : "Response could not be parsed as valid openui-lang",
- hint: `The entire response must be valid openui-lang code starting with root = ${library.root ?? "Root"}(...)`,
- });
- }
-
- // Parser validation errors → enriched OpenUIError (with hints)
- if (result?.meta?.errors?.length) {
- errors.push(
- ...enrichErrors(
- result.meta.errors,
- library.toJSONSchema(),
- Object.keys(library.components),
- ),
- );
- }
-
- // Runtime eval errors (collected per-prop by evaluateElementProps)
- errors.push(...runtimeErrorsRef.current);
-
- // Render errors (collected by error boundary via reportError)
- errors.push(...renderErrorsRef.current);
- renderErrorsRef.current = [];
-
- // Query/mutation tool errors — already OpenUIError, pass through directly
- errors.push(...(querySnapshot.__openui_errors ?? []));
-
- // Deduplicate — only fire when errors actually change
- const key = JSON.stringify(errors);
- if (key === lastErrorKeyRef.current) return;
- lastErrorKeyRef.current = key;
+ // Keep error collection first: its effect refreshes this ref before the
+ // observability effect publishes the terminal stream event.
+ const { errorsRef, errorRevision } = useOpenUIErrors({
+ response,
+ isStreaming,
+ result,
+ evaluatedResult,
+ library,
+ querySnapshot,
+ parseExceptionRef,
+ runtimeErrorsRef,
+ renderErrorsRef,
+ onError,
+ });
- // Fire onError or fall back to console.warn
- if (propsRef.current.onError) {
- propsRef.current.onError(errors);
- } else if (errors.length > 0) {
- for (const e of errors) {
- console.warn(`[openui] ${e.source}/${e.code}: ${e.message}`);
- }
- }
- }, [isStreaming, response, result, evaluatedResult, querySnapshot, library]);
+ useStreamingObservability({ response, isStreaming, result, errorsRef, errorRevision });
return { result: evaluatedResult, parseResult: result, contextValue, isQueryLoading };
}
diff --git a/packages/react-lang/src/hooks/useStreamingObservability.integration.test.ts b/packages/react-lang/src/hooks/useStreamingObservability.integration.test.ts
new file mode 100644
index 000000000..7a772424e
--- /dev/null
+++ b/packages/react-lang/src/hooks/useStreamingObservability.integration.test.ts
@@ -0,0 +1,176 @@
+// @vitest-environment jsdom
+import type { OpenUIError, ParseResult, QuerySnapshot } from "@openuidev/lang-core";
+import { observability, type ObservabilityEvent } from "@openuidev/observability";
+import { act, createElement, useRef } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { Library } from "../library";
+import { useOpenUIErrors } from "./useOpenUIErrors";
+import { useStreamingObservability } from "./useStreamingObservability";
+
+(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+const response = 'root = Root("done")';
+const result = {
+ root: {
+ type: "element",
+ typeName: "Root",
+ props: {},
+ partial: false,
+ },
+ meta: {
+ incomplete: false,
+ unresolved: [],
+ orphaned: [],
+ statementCount: 1,
+ errors: [],
+ },
+ stateDeclarations: {},
+ queryStatements: [],
+ mutationStatements: [],
+} satisfies ParseResult;
+
+const library = {
+ root: "Root",
+ components: { Root: {} },
+} as unknown as Library;
+
+function Harness({
+ isStreaming,
+ queryErrors,
+ currentResponse = response,
+}: {
+ isStreaming: boolean;
+ queryErrors: OpenUIError[];
+ currentResponse?: string;
+}) {
+ const parseExceptionRef = useRef<OpenUIError | null>(null);
+ const runtimeErrorsRef = useRef<OpenUIError[]>([]);
+ const renderErrorsRef = useRef<OpenUIError[]>([]);
+ const querySnapshot = {
+ __openui_loading: [],
+ __openui_refetching: [],
+ __openui_errors: queryErrors,
+ } satisfies QuerySnapshot;
+
+ const { errorsRef, errorRevision } = useOpenUIErrors({
+ response: currentResponse,
+ isStreaming,
+ result,
+ evaluatedResult: result,
+ library,
+ querySnapshot,
+ parseExceptionRef,
+ runtimeErrorsRef,
+ renderErrorsRef,
+ });
+
+ useStreamingObservability({
+ response: currentResponse,
+ isStreaming,
+ result,
+ errorsRef,
+ errorRevision,
+ });
+ return null;
+}
+
+let container: HTMLDivElement;
+let root: Root;
+
+beforeEach(() => {
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ root = createRoot(container);
+});
+
+afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+});
+
+describe("streaming observability integration", () => {
+ it("uses a new id when the mounted Renderer starts another stream", () => {
+ const events: ObservabilityEvent[] = [];
+ const removeListener = observability.listenAll((event) => {
+ if (event.detail.kind === "react-lang:stream") events.push(event);
+ });
+
+ act(() =>
+ root.render(
+ createElement(Harness, {
+ isStreaming: true,
+ queryErrors: [],
+ currentResponse: "first",
+ }),
+ ),
+ );
+ act(() =>
+ root.render(
+ createElement(Harness, {
+ isStreaming: false,
+ queryErrors: [],
+ currentResponse: "first",
+ }),
+ ),
+ );
+ act(() =>
+ root.render(
+ createElement(Harness, {
+ isStreaming: true,
+ queryErrors: [],
+ currentResponse: "second",
+ }),
+ ),
+ );
+ act(() =>
+ root.render(
+ createElement(Harness, {
+ isStreaming: false,
+ queryErrors: [],
+ currentResponse: "second",
+ }),
+ ),
+ );
+ removeListener();
+
+ const streamIds = events.map((event) => event.detail.id);
+ expect(events.map((event) => event.detail["phase"])).toEqual([
+ "streaming",
+ "settled",
+ "streaming",
+ "settled",
+ ]);
+ expect(streamIds[0]).toBe(streamIds[1]);
+ expect(streamIds[2]).toBe(streamIds[3]);
+ expect(streamIds[2]).not.toBe(streamIds[0]);
+ });
+
+ it("republishes settled with the same id when a query error arrives later", () => {
+ const events: ObservabilityEvent[] = [];
+ const removeListener = observability.listenAll((event) => {
+ if (event.detail.kind === "react-lang:stream") events.push(event);
+ });
+
+ act(() => root.render(createElement(Harness, { isStreaming: true, queryErrors: [] })));
+ act(() => root.render(createElement(Harness, { isStreaming: false, queryErrors: [] })));
+
+ const queryError: OpenUIError = {
+ source: "query",
+ code: "tool-error",
+ message: "Query failed",
+ };
+ act(() =>
+ root.render(createElement(Harness, { isStreaming: false, queryErrors: [queryError] })),
+ );
+ removeListener();
+
+ const settled = events.filter((event) => event.detail["phase"] === "settled");
+ expect(settled).toHaveLength(2);
+ expect(settled[0]?.detail.id).toBe(settled[1]?.detail.id);
+ expect(settled[0]?.detail["errors"]).toEqual([]);
+ expect(settled[1]?.level).toBe("error");
+ expect(settled[1]?.detail["errors"]).toEqual([queryError]);
+ expect(settled[1]?.detail["response"]).toBe(response);
+ });
+});
diff --git a/packages/react-lang/src/hooks/useStreamingObservability.test.ts b/packages/react-lang/src/hooks/useStreamingObservability.test.ts
new file mode 100644
index 000000000..ce5b369be
--- /dev/null
+++ b/packages/react-lang/src/hooks/useStreamingObservability.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+ advanceStreamingObservability,
+ createStreamingObservabilityState,
+} from "./useStreamingObservability";
+
+describe("streaming observability lifecycle", () => {
+ it("does not create an event for content that was never streamed", () => {
+ const state = createStreamingObservabilityState();
+ const idFactory = vi.fn(() => "stream-1");
+
+ expect(
+ advanceStreamingObservability(state, false, 'root = Card("done")', "[]", idFactory),
+ ).toBeNull();
+ expect(idFactory).not.toHaveBeenCalled();
+ });
+
+ it("uses one stable id for every update and the settled event", () => {
+ const state = createStreamingObservabilityState();
+ const idFactory = vi.fn(() => "stream-1");
+
+ expect(advanceStreamingObservability(state, true, "root = Car", null, idFactory)).toEqual({
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 1,
+ });
+ expect(
+ advanceStreamingObservability(state, true, 'root = Card("done")', null, idFactory),
+ ).toEqual({
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 2,
+ });
+ expect(
+ advanceStreamingObservability(state, false, 'root = Card("done")', "[]", idFactory),
+ ).toEqual({
+ id: "stream-1",
+ phase: "settled",
+ updateIndex: 2,
+ });
+ expect(idFactory).toHaveBeenCalledOnce();
+ });
+
+ it("emits once per response and unchanged settled snapshot", () => {
+ const state = createStreamingObservabilityState();
+ const idFactory = () => "stream-1";
+
+ expect(
+ advanceStreamingObservability(state, true, "root = Car", null, idFactory),
+ ).not.toBeNull();
+ expect(advanceStreamingObservability(state, true, "root = Car", null, idFactory)).toBeNull();
+ expect(
+ advanceStreamingObservability(state, false, "root = Car", "[]", idFactory),
+ ).not.toBeNull();
+ expect(advanceStreamingObservability(state, false, "root = Car", "[]", idFactory)).toBeNull();
+ });
+
+ it("starts a new id when a settled Renderer streams again", () => {
+ const state = createStreamingObservabilityState();
+ const idFactory = vi
+ .fn<() => string>()
+ .mockReturnValueOnce("stream-1")
+ .mockReturnValueOnce("stream-2");
+
+ expect(advanceStreamingObservability(state, true, "first", null, idFactory)).toEqual({
+ id: "stream-1",
+ phase: "streaming",
+ updateIndex: 1,
+ });
+ expect(advanceStreamingObservability(state, false, "first", "[]", idFactory)).toEqual({
+ id: "stream-1",
+ phase: "settled",
+ updateIndex: 1,
+ });
+ expect(advanceStreamingObservability(state, true, "second", null, idFactory)).toEqual({
+ id: "stream-2",
+ phase: "streaming",
+ updateIndex: 1,
+ });
+ expect(advanceStreamingObservability(state, false, "second", "[]", idFactory)).toEqual({
+ id: "stream-2",
+ phase: "settled",
+ updateIndex: 1,
+ });
+ expect(idFactory).toHaveBeenCalledTimes(2);
+ });
+
+ it("republishes settled when the error snapshot changes", () => {
+ const state = createStreamingObservabilityState();
+ const idFactory = () => "stream-1";
+
+ advanceStreamingObservability(state, true, "root = Card()", null, idFactory);
+ advanceStreamingObservability(state, false, "root = Card()", "[]", idFactory);
+
+ expect(
+ advanceStreamingObservability(
+ state,
+ false,
+ "root = Card()",
+ '[{"code":"query-error"}]',
+ idFactory,
+ ),
+ ).toEqual({
+ id: "stream-1",
+ phase: "settled",
+ updateIndex: 1,
+ });
+ expect(
+ advanceStreamingObservability(
+ state,
+ false,
+ "root = Card()",
+ '[{"code":"query-error"}]',
+ idFactory,
+ ),
+ ).toBeNull();
+ });
+});
diff --git a/packages/react-lang/src/hooks/useStreamingObservability.ts b/packages/react-lang/src/hooks/useStreamingObservability.ts
new file mode 100644
index 000000000..3c2bd4013
--- /dev/null
+++ b/packages/react-lang/src/hooks/useStreamingObservability.ts
@@ -0,0 +1,154 @@
+import type { OpenUIError, ParseResult } from "@openuidev/lang-core";
+import { observability } from "@openuidev/observability";
+import { useEffect, useRef } from "react";
+
+type CurrentRef<T> = { current: T };
+
+export interface UseStreamingObservabilityOptions {
+ response: string | null;
+ isStreaming: boolean;
+ result: ParseResult | null;
+ errorsRef: CurrentRef<OpenUIError[]>;
+ errorRevision: number;
+}
+
+export interface StreamingObservabilityState {
+ id: string | null;
+ updateIndex: number;
+ lastResponse: string | null;
+ hasPublishedStreamingSnapshot: boolean;
+ settled: boolean;
+ lastSettledErrorKey: string | null;
+}
+
+export interface StreamingObservabilityUpdate {
+ id: string;
+ phase: "streaming" | "settled";
+ updateIndex: number;
+}
+
+let fallbackId = 0;
+
+function createStreamId(): string {
+ if (typeof globalThis.crypto?.randomUUID === "function") {
+ return globalThis.crypto.randomUUID();
+ }
+ fallbackId += 1;
+ return `openui-lang-${Date.now().toString(36)}-${fallbackId.toString(36)}`;
+}
+
+export function createStreamingObservabilityState(): StreamingObservabilityState {
+ return {
+ id: null,
+ updateIndex: 0,
+ lastResponse: null,
+ hasPublishedStreamingSnapshot: false,
+ settled: false,
+ lastSettledErrorKey: null,
+ };
+}
+
+/** Advances a Renderer through successive stream lifecycles. */
+export function advanceStreamingObservability(
+ state: StreamingObservabilityState,
+ isStreaming: boolean,
+ response: string | null,
+ settledErrorKey: string | null = null,
+ idFactory: () => string = createStreamId,
+): StreamingObservabilityUpdate | null {
+ if (isStreaming) {
+ // A mounted Renderer can be reused for another message. Once the previous
+ // stream has settled, the next streaming transition starts a new identity.
+ if (state.settled) Object.assign(state, createStreamingObservabilityState());
+
+ state.id ??= idFactory();
+ if (state.hasPublishedStreamingSnapshot && state.lastResponse === response) return null;
+
+ state.hasPublishedStreamingSnapshot = true;
+ state.lastResponse = response;
+ state.updateIndex += 1;
+ return { id: state.id, phase: "streaming", updateIndex: state.updateIndex };
+ }
+
+ // A Renderer mounted only for static or historical content never starts a stream.
+ if (!state.id) return null;
+ if (
+ state.settled &&
+ (settledErrorKey === null || state.lastSettledErrorKey === settledErrorKey)
+ ) {
+ return null;
+ }
+
+ state.settled = true;
+ state.lastSettledErrorKey = settledErrorKey;
+ return { id: state.id, phase: "settled", updateIndex: state.updateIndex };
+}
+
+function parserMetadata(result: ParseResult | null) {
+ if (!result) return undefined;
+ return {
+ incomplete: result.meta.incomplete,
+ unresolved: result.meta.unresolved,
+ orphaned: result.meta.orphaned,
+ statementCount: result.meta.statementCount,
+ };
+}
+
+/**
+ * Publishes the incremental OpenUI Lang stream lifecycle. The stable id is
+ * created only after this Renderer instance has actually entered streaming.
+ */
+export function useStreamingObservability({
+ response,
+ isStreaming,
+ result,
+ errorsRef,
+ errorRevision,
+}: UseStreamingObservabilityOptions): void {
+ const streamRef = useRef<StreamingObservabilityState>(createStreamingObservabilityState());
+
+ useEffect(() => {
+ const errors = errorsRef.current;
+ const settledErrorKey = isStreaming ? null : JSON.stringify(errors);
+ const update = advanceStreamingObservability(
+ streamRef.current,
+ isStreaming,
+ response,
+ settledErrorKey,
+ );
+
+ if (isStreaming) {
+ if (update) {
+ observability.info({
+ id: update.id,
+ kind: "react-lang:stream",
+ phase: update.phase,
+ updateIndex: update.updateIndex,
+ response,
+ responseLength: response?.length ?? 0,
+ parser: parserMetadata(result),
+ message: "OpenUI Lang is streaming",
+ });
+ }
+ return;
+ }
+
+ if (update?.phase === "settled") {
+ observability(errors.length > 0 ? "error" : "info", {
+ id: update.id,
+ kind: "react-lang:stream",
+ phase: update.phase,
+ updateIndex: update.updateIndex,
+ response,
+ responseLength: response?.length ?? 0,
+ parser: parserMetadata(result),
+ errors,
+ errorCount: errors.length,
+ message:
+ errors.length > 0
+ ? `OpenUI Lang settled with ${errors.length} error${errors.length === 1 ? "" : "s"}`
+ : "OpenUI Lang settled",
+ });
+ }
+ }, [isStreaming, response, result, errorsRef, errorRevision]);
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 481076771..16e2570c5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -583,13 +583,13 @@ importers:
version: link:../../../packages/react-ui
'@vercel/connect':
specifier: 0.2.2
- version: 0.2.2(@ai-sdk/[email protected]([email protected]))([email protected]([email protected]))([email protected](oqjwrf4zrwhkmsh6cw25wqbywa))
+ version: 0.2.2(@ai-sdk/[email protected]([email protected]))([email protected]([email protected]))([email protected](334bb9546b1c81dc4133f38010d6ba8c))
ai:
specifier: 7.0.0-beta.178
version: 7.0.0-beta.178([email protected])
eve:
specifier: ^0.11.7
- version: 0.11.10(oqjwrf4zrwhkmsh6cw25wqbywa)
+ version: 0.11.10(334bb9546b1c81dc4133f38010d6ba8c)
next:
specifier: 16.2.6
@@ -711,7 +711,7 @@ importers:
version: link:../../packages/react-ui
deepagents:
specifier: ^1.10.5
- version: 1.11.1(netxvpgoa72hqc2a7n7pcqhqha)
+ version: 1.11.1(91bd0eba1cf83c982119a44cf5cfde79)
langchain:
specifier: ^1.5.1
@@ -730,7 +730,7 @@ importers:
devDependencies:
'@langchain/langgraph-cli':
specifier: ^1.4.3
- version: 1.4.3(bhtnaejseqq2m7qzl44jvsnn2m)
+ version: 1.4.3(034c2039ce40cfd9923293160ef8005c)
'@openuidev/cli':
specifier: workspace:*
version: link:../../packages/openui-cli
@@ -769,7 +769,7 @@ importers:
version: 0.0.53
'@ag-ui/mastra':
specifier: ^1.0.1
'@mastra/core':
specifier: 1.15.0
@@ -1900,6 +1900,9 @@ importers:
'@openuidev/lang-core':
specifier: workspace:^
version: link:../lang-core
+ '@openuidev/observability':
+ specifier: workspace:^
+ version: link:../observability
react:
specifier: 'catalog:'
version: 19.2.4
@@ -1913,6 +1916,15 @@ importers:
'@types/react':
specifier: 'catalog:'
version: 19.2.17
+ '@types/react-dom':
+ specifier: 'catalog:'
+ version: 19.2.3(@types/[email protected])
+ jsdom:
+ specifier: 'catalog:'
+ version: 26.1.0
+ react-dom:
+ specifier: 'catalog:'
+ version: 19.2.4([email protected])
vitest:
specifier: ^4.0.18
@@ -4256,89 +4268,105 @@ packages:
resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
cpu: [arm]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [arm]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
@@ -4723,30 +4751,35 @@ packages:
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@mariozechner/[email protected]':
resolution: {integrity: sha512-AGuJdgKsmJdm4Pych7kv3sqe591ERRaAHW3xjLooiFzn8J+PxUyof++7YZrB5Y5tpnTO+K18Og3taj2NpluCRQ==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@mariozechner/[email protected]':
resolution: {integrity: sha512-DXBEAiuMpk7dhS1a9NzNxVAFi1vaKoPu7rQNgY8LIDLGrK3lnIp3nT10DUum+PKVJoJppIP+NAA8IZe4DMNDPw==}
engines: {node: '>= 10'}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@mariozechner/[email protected]':
resolution: {integrity: sha512-WORrMLd6EpElEME7JRKfSaY34nW1P5LbdgK5YNCS1ncG2LqmITsSMEJ8nh2mpvxb3TxqbOOKgY7k9eMJYlW9Mw==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@mariozechner/[email protected]':
resolution: {integrity: sha512-/DHn+1DrfL6oRaPPWXaOKvonFFrni666fxd+zFqiQEfvBH0tsHVWjq9iqBk0oDp0qaPA72lIMy5BptxISBEhZQ==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@mariozechner/[email protected]':
resolution: {integrity: sha512-O5FHD3ErkMwMhNzAfu3ggy0ug4z7btZuoQgwwxlzPrwV2bxlD6WDpqBY4NCgICAgZdDKdp+loUEKVAVt8aYnhQ==}
@@ -5092,96 +5125,112 @@ packages:
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-OJYkCd5pj/QloBvoEcJ2XiMnlJkRv9idWA/j0ugSuA34gMT6f5b7vOiCQHVRpvStoZUknhl6/UxOXL4OwtdaBw==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-RPOvqlYBbcQjkz9VQQDZ2T2bARIjXZV1KFlt+V2Mr6SW/e4I9fcKsaA0hdyf2FHoTlsV2xnBd5Y912rP/1Ce6w==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-Re6PZtjBDd0aMU+VcZcC/PrIvj4WhrjDYtMhhCVQamWN4L90EVP0pcEOBQD25prSlw7OzNw5QpHLWMilRLsRNw==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-iknK80pWlNDnkdSr13bd8mMuG3Z2oTxODwsZHvuMY7caMk77+rBLdHVWsy8v2EVa3ZojJ/+wJX5fnq8va6Gv8A==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-S4J2v+8tT3NIO9u2q+S0G5KdvNDjXfAv06OhfOzNDaBn5rw84DGXWndOEB7d5/x852A20sW1M56vhC/tRVbccQ==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-URUTu1+dMkxJsPFgm+OeEvq9wf5sujw0EvgYy80TDGHTSLTnIHeqb0Eu8A3sC95IRgjejQL+kC4mw+4yPxiAXA==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-qyogG9QtBzWxgJfeGBvOEHI3851gTfCF3wLZ5RDLTBJGAmE9p1qDwKCOdrBrvBzRvYDT+gUDp72pzlSEfAXgNA==}
engines: {node: '>= 10'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-penuEdkwU2OOAiS+n4LE8T/VIoCfAI01QcLZTJ2xc3+l4Q22L/DzURocmI2LU1b+8BMQoLAP1Sze3uYAZT05Bg==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-2eEBDkFlMMNQnkTyPBhQOAyn2qMxyG2eE7GPH2WIDGEpEILcBPI/jdSv4t6xupSP+ot/jkfrCShLAa7+ZUPcJQ==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-DOj182mPV8G3UkrayLoREM5YEYI+Dk5wv7Ox9xl1fFibAELEsFD0lDPfHIeILlutMMfdyhlzYPELG3peuKaurw==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-Vhe4ZDuBpmMogrGi5D4R2Kq4JAQlj6+wvgaFYy31zfES0zPmt6TLA+cuYpM/OLrPZjo2MYQTHVqNUSCR6+fDZQ==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-ZM0BKJm3FZ+guG6WT6PcyOLtp6paZ5tngcJC/uUKvLW4Y0TQnnVi1+UGdo8Q6Yxp5gaS82pmC1rD/oFlhkWB3g==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-oicJwRlyOoZXVlxmIMaTq7f8pN9QNbdes0q2FXfRsPhfCi8n8JmOZJm5oo1pwDaFbnnD421rVU409M3evFbIqg==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-HKQ5SP/V/ub73UvF7n/zeJlxk2kLmtL7Wzrg4WfmkjmNos5onJ2tKu7yZOPdL18A6Svfn3max29ym+ry7NkK4g==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-srvian89JahFLw1YLBEuhvPJ0DO5lpUeJQMXy4xYo7g628ZlNgXdNkqoxSAv9OYrBfByh6vxISMwW/mRbzCY+g==}
engines: {node: '>= 10'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-rY/YaumrZaS0//94BnHLF5VSRp0GFUO4GvXNuoCBb0cGSci96yO+p1JaNL2aq9YZAYv9cuZRziV02x5IQH/wjg==}
@@ -5648,48 +5697,56 @@ packages:
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-Xkb5QCOywz/YbL+8LVQSzOxuz2jhRweBjr4BnQO7CQXAtQLLCNoll7v2qLg9OCzdqdhFw9uNgZ6aTBVADBhiPg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-IbVb+m0iL053WitFNnQbtmd8OjYGr4Xn5NTuAiYz8tJBtn82okEZFi0OgaeaHQE4aPZGOKPcSVlt1OMPtMoPCw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-Sc/GAiyelxg8oXlBgmJI6OuKKHmg4rF0RvTLC8eL5V3qKDXrMdVWiJziwVBqN5oiFEog35ZM1/YNF63IZOdZjw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-KHYS3oQJ5r1QBVAVubUy6UPRWYghqkjCOfNlGeH/sWlmfeM2OD74+Stc8eHmVm7QI2wDooOIlZfUso0Yz0jyRg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-WyacIrs13ewOnGngxNmPF00xn0+aOYHTMSSMljNN3VShSbqB0A7ZEikR7q9fmmnBTf/jloQUO6bjzK85BFfl0w==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-mP69bh2L/VVq10UEQ3wb0EsO0472TzOIZUfS/ADmxnr4gSxAzhRbO8w5QryL3BNyyyjSaXIlrAnAKO6G3srGwg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-B4w1uz+GPVD5iRNn9StLSG0ug5DNAy5YQVswjPy5fXNNO6JyADvmu4KZyE6tWCA6Kbz/84icD6RJ1TKVis2HSg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@oxc-minify/[email protected]':
resolution: {integrity: sha512-p3nU1bo2t+QRvvqOPUqI8aEk8puhYdMq5cnjulovfKykWRi8cMcJJvuLp+RPkf45lUcTQdNG/YMFqR5eYGZfwA==}
@@ -5809,96 +5866,112 @@ packages:
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-yrjmLj8ixPB25yqvPGr28meGjb+keed7m1GqqY/0uqkhZIoT4t9zmfwUgFEtC33C7dtE+UQ7TU0IaVxf97SWJg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-EoTCZneNFU/P2qrpEM+RHmQwt+CvDkyGESG6qhr7KaegXLZwePfbrkCDfAk8/rhxbDUVGsZILX+2tqPzFtoFWA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-ggGMQTN8Agwxp2WiLMpdY671dt0qTDJWiWlJeig3HnUwTnerRl0J2JdGVghWBeDcss2D9S2V2Js6dZHEiVabVA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-zALjmZYgxFLHjXeudcDF0xFGNydTAtkAeXAr2EuC17ywCyFxcmQra4w0BMde0Yi/re4Bi4iwEoEXtYN7l6eBLQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-IgTs8xYAFgAUGNmR65tIqjlJ8vKgrfXzC515e9goSdfMyKQV4aJpd2pUUudU4u51G64H0/DSEJEXKOraxm9ZCA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-fPP8M6zQLS7Jz7o9d5ArUSuAuSK3e+WCYVrCpdzeCOejidtZExJ9tjhDrAd3HEPqARBCPmdpqxESPFqy44vkBQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-A1x+PMWZmSGaFVOx2YeNTFau8uD+QO14/vLP4GrcuvUPs3+nBkUOjy9Lus86ftHsDojjYMbvBelmKc3F7Rv08g==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-7IcC4Ao02oGpfnjt+X/oF4U2mllo2qoSkw5xxiXNKL9MCTsTiAC6616beOuehdxGcnz1bRoPC1RQ2f1GQDdN+g==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-zBqpfRo2myWPrPo5xUjeZqlnPXPXsX8BcWtWff66/eGRQdbPjhzPgXa/F+AtxT2afUViPxbuDlwscMKzQ5tg+g==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-pbXIhiNFHoqWeqDNLiJ9JkpHz1IM9k4DXa66x+1GTWMG7iLxtkXgE53iiuKSXwmk3zIYmaPVfBvgcAhS583K4Q==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-2M1DPm/8w9I//YzFlFC9qXw+r2tJFh5CYwRlYTq2vUJQS7qoQftEDeCZ8EnN7KHtvSiXvYj8mZI5pR7DpXmcEw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-MYCguB9RvBvlSd6gbuNI7QwiLoCCAlGnlRJFPrzLI6U1/9wkC/WK6LtBAUln55H1Ctqw45PWmqrobKoMhsYQzQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-8aRDbZ/U/jO8N7go1MO72jtbpb4uswV8d7vOkMvt/BPgZiyEYvl1VIWK4ESxZZhnJ4tqwVldgX7dNiP/eB1Jdg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-5eY0B/bxf1xIUxb4NOTvOI3KWtBQfPWYyKAzgcrCt0mDibSZygVpO1Pz8bkeiSZ5Jj9+M09dkggG3H8I5d0Uyg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-xRqpeI8U2sQQS1W5BMWRyMTxtagkuLG2dEWruet5lFsWHTvBth11/TpSaJatHdqVVwHN0q3uuoS9zRsGinq8hg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@oxc-parser/[email protected]':
resolution: {integrity: sha512-Gld0ajrFTUXNtdw20fVBuTQx66FA75nIVg+//pPfR3sXkuABB4mTBhl3r9JNzrJpgW//qiwxf0nWXUWGJSL3UQ==}
@@ -6003,41 +6076,49 @@ packages:
resolution: {integrity: sha512-vDT3KHgzYp47gmtNOqL2VNhCyl5Zv643eyxm//A68J8DeUGXrvD1pZFiaT4jSfe+RInfnn1R2yVHye4enx6RnA==}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-+kMlQvbzfyEYtu5FcjE4p+ttBLpKW4d/AsAsuE69BxV6V4twZJeIQZFfD8gh/wqglY0MkPSezWXQH0jBV13MUw==}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-shjfMhmZ3gq9fv/w7bi3PnZlgOPG+2QAOFf0BJF0EgBSIGZ6PMLN2zbGEblTUYB/NKVDRyYhE2ff3dJ1QqNPkA==}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-zGelwFR5oRo+b69k8Lrzun86DyUHzfKN6cnjbR9l7Z7NIRznOE/2ZvPa1IUKqAL2PzAXOdwkfVqNvO1H2RlpAw==}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-qxZ1SWCXJY0eyhAlP6Lmo9F2Nrtx7EkYj9oCgL8apDPCwXwCEDA2U697bbT81JIc2IrVjxO4KX6WU2N+oN9Z4w==}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-sGCecF3cx2DFlH4t/z7ApnOnXqN48p5p5mlHDEnHTAukQa2P+qMVE4CwyWE9W+q/m3QJ7kKfGrIjax31f44oFQ==}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-k/VlMMcSzMlahb3/fENM4rTlsJ0s3fFROA0KXPBmKggqmTSaE383sl8F3KCOXPLmVsYfW6hCitMhXCEtNeZxxg==}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-8hbnZyNi97b/8wapYaIF9+t9GmZKBW2vunaOc3h9HGJptH7b7XpvZqOTBSm/MpTjr7H497BlgOaSfLUdhmy2bw==}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@oxc-resolver/[email protected]':
resolution: {integrity: sha512-MvyGik3a6pVgZ0t/kWlbmFxFLmXQJwgLsY2eYFHLpy0wGwRbfzeIGgDwQ3kXqE30z+kSXennRkCrT7TUvkptNg==}
@@ -6106,48 +6187,56 @@ packages:
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-aUUptri02E4nqkUvyA+2oYkmU20pYnHIpNLPZOgom0kAa0Fx9X6QFKqKm1MopyucWolQ9XTgCK2PrupSSBdCdQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-d28AT+SfcAYFnulI2C8HJ5OeoUa5w+eMpwy0uMzbU/3zXJpFjjFOvJlEL8FNvx7HBEENj5IfgD+aXdNzEEn1Tg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-P6XVhw+MJsjeliWJ6BBKdC0HU1VEiwMRHtqUADK+jK5wiqgzt3/JhIcMuRLzBPYfnOujLpe+fm63yEzKUIAcSA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-6QUicErqoLpCVsXPYI+OEYJ95TjiV+trvX9VeCuyVcyL5p0Opi7DFQL2c1DcGHi1c9cqz1h09mUKCZ7Y52kxfw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-r2Jk0vfcnHnkPOjLnWvpGVTFcYDirGICBJYraCkWeplhPZ2Sgg9GvDVgah9VFOHRZVtK6XQynELP9A8EB/Ne0Q==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-lIsdGq4LA1IlbrZlmrhP/p0pCo4+5jrAlLp9BMzIHaV4mILBSr+ZtuTDkML4117cLHdzoWOqw0s3Rb7igOWtxw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-y+9FbVRBhUtHBVn0xHiVcaNHkoRudIhlKhRk1+CclE1uGD6af3xznTjCOrKGB7HZ2SzlCWLZwQGm/KERpUjX1w==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@oxc-transform/[email protected]':
resolution: {integrity: sha512-Ul5Fu6zPL7kjTbtBU30HaRFHPL3bjjpdieHmAXJlJDuFukuOXqVD6dS70b314IjFy/rbqkD8OK4MQ4408eEjyg==}
@@ -6207,36 +6296,42 @@ packages:
engines: {node: '>= 10.0.0'}
cpu: [arm]
os: [linux]
+ libc: [glibc]
'@parcel/[email protected]':
resolution: {integrity: sha512-9c6AUHgHoG+IY88MRIHupztQiQnrbqHYQjkM2btA+Bf/wQnQMuiD0Wfk1EVv3TlNT3x41uU71rn6E4xh/+zvkw==}
engines: {node: '>= 10.0.0'}
cpu: [arm]
os: [linux]
+ libc: [musl]
'@parcel/[email protected]':
resolution: {integrity: sha512-yHRqS2owEXe6Hic9z6Mh1ECsCd+ODVOGvZDyciqRd21+v+o+DnXMOrw50DSpIG2sb8GPEaPPmfeCAWKPJdq46g==}
engines: {node: '>= 10.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@parcel/[email protected]':
resolution: {integrity: sha512-WhB2e/V7rqdHHWZusBSPuy5Ei8S6lSz6FE5TKKQz5h3a0O+C+mhY7vxU9b/stqvMb8beLnPY82ZrFTLKs+SrKA==}
engines: {node: '>= 10.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@parcel/[email protected]':
resolution: {integrity: sha512-ulGE6x6Oz6iAwg75T8YQSoguBWasniIbX+QWpaYPcCnDOpdWX3k+4xbEYPZVLxOuoJI+svJJPD3sEj8G7lrQ3A==}
engines: {node: '>= 10.0.0'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@parcel/[email protected]':
resolution: {integrity: sha512-tkBYKt7YQrjIJWYDnto2YgO8MRkjlMTSNoRHzsXinBqbLdeOM3L32wPZJvIZxqaLMfSlS/4sUjH/6STVP/XDLw==}
engines: {node: '>= 10.0.0'}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@parcel/[email protected]':
resolution: {integrity: sha512-dtjbDxKSDPQ8AmA+pS4OFaHE1FKrjtGpLGBxw85uKFkRorjNbvDM/aFPgqosu40wprbp1xw2ZSxIKqghCUHe2w==}
@@ -7756,72 +7851,84 @@ packages:
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-D+TgkdgM1vu+7/Fpf8+v0ARW+RXEP9Ccazgm8zQ4JFFd9Q7SrYQ2TakU5S5ihazQDgpKyAgZDOcIFsvoHmTZ8w==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-b/CgbwAJpmrRLp02RPfhbudf5tZnN9nsPWK82znefso832etkem8H7FSZwxrOI9djcdTP7U6YfNhbRnh7djErg==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@rolldown/[email protected]':
resolution: {integrity: sha512-wUqdwJBbAv0APN87GecstdMUtLjjNTs0hBALpxETD73mccFxdmt/XeizXDtN5RAlBwNKmI+Tg+blect2G+8IeQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@rolldown/[email protected]':
resolution: {integrity: sha512-4EII1iNGRUN5WwGbF/kOh/EIkoDN9HsupgLQoXfY+D1oyJm7/F4t5PYU5n8SWZgG0FEwakyM8pGgwcBYruGTlA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-9DtF35qR9/NrfhM4oxLplCzVVjE+KKm8Pjemi0i/sdhAWkUasjmSo8WTTubNJClhSHCfyk2yeyoXDQEDPtDAAw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-AH8oq3XqQo4IibpVXvPeLDI5pzkpYn0WiZAfT05kFzoJ6tQNzwRdDYQ45M8I/gslbodRZwW8uxLhbSBbkv96rA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-RzuHrBh8X8Hntd2N4VR02QGEciq/9JhcZoTpR/Cee6otRrlILGCf3cg2ygHuih+ZebUnWmMrDX6ITI85btO6rQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-cLnjV3xfo7KslbU41Z7z8BH/E1y5mzUYzAqih1d1MDaIGZRCMqTijqLv76/P7fyHuvUcfGsIpqCdddbxLLK9rA==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-MK7L0018jjh1jR3mh21G2j1zAVcpscJBlPo2z19pRjv2XOYGRhaV4LyiD8HO6nCDdZln9IFgCMIV5yt4E3klGQ==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@rolldown/[email protected]':
resolution: {integrity: sha512-0phclDw1spsL7dUB37sIARuis2tAgomCJXAHZlpt8PXZ4Ba0dRP1e+66lsRqrfhISeN9bEGNjQs+T/Fbd7oYGw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@rolldown/[email protected]':
resolution: {integrity: sha512-gyrxLQ9NfGb/9LoVnC4kb9miUghw1mghnkfYvNHSnVIXriabnfgGPUP4RLcJm87q3KgYz4FYUG8IDiWUT+CpSw==}
engines: {node: ^20.19.0 || >=22.12.0}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@rolldown/[email protected]':
resolution: {integrity: sha512-0ag/hEgXOwgw4t8QyQvUCxvEg+V0KBcA6YuOx9g0r02MprutRF5dyljgm3EmR02O292UX7UeS6HzWHAl6KgyhA==}
@@ -7984,66 +8091,79 @@ packages:
resolution: {integrity: sha512-ggXnsTAEzNQx74XpunRsiZ9aBZDsI7XIa0hm2nzR9f4WzH5/f/d73ZSDaC5ejJ8YLY4NW+V3wr0tjOaeCq8hqA==}
cpu: [arm]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-2vng+FlzNUhKZxtej3IUqJgbZoQk2M/dwQM20+ULV0R/E/8tr9/P6uEf2iiGIk4HL0zMKh5Jry7mUHdUOvyGgA==}
cpu: [arm]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-LLLFZKt4/Nraf9rxDkhiU8QVgLF4WmCkfr0L4fj0fPfIZFBib0DeiFk1hhaYKd03LFAFJcxHslhDFlNJLylf5Q==}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-WJkdQCvS9sWNOUBJZfQRKpZGFBztRzcowI+nndmflKgU4XY+3a420FgTOSKTsVqJbnzSxeT4vaJalpOaPo2YCQ==}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-PwHXCCS2n64/1Ot6rP1YEYA02MGYBcQlr8CSZZyrUG2O7NH6NklYmvr9v3Jy+5e/eDeNchc/ukmKJi9LuflMIQ==}
cpu: [loong64]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-vUjxINQu3RC8NZS3ykk1gN65gIz8pAopOq2HXuZhiIxHdx7TFvDG+jgrdSgInu1Eza4/Rfi2VzZgyIgEH4WOaw==}
cpu: [loong64]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-wzko4aJ13+0G3kGnviCg5gnXFKd40izKsrf2uOw12US4XqprkDrmwOpeW14aSNa37V8bfPcz5Fkob6LZ3BAPmA==}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-8120ue0JUMSwy11stlwnfdX3pPd+WZYGCDBwEHWtIHi6pOpZmsEF5QKB7a/UN+XFdqvobxz98kv8RTqikyCEBw==}
cpu: [ppc64]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-XLFHnR3tXMjbOCh2vtVJHmxt+995uJsTERQyseFDRA0xxMxyTZPLa3OIUlyFaO4mF/Lu0FjmWHCuPXJT1n/IOg==}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-se6yXvNGMIl0f+RQzyh7XAmia8/9kplQx424wnG2w0C1oi6XgO6Y8otKhdXFHbHs88Ihavzmvh1NWjuovE76BQ==}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-gNoxRefktVIiGflpONuxWWXZAzIQG++z9qHO3xKwk4WdDMuQja3JHGfE1u0i3PfPDyvhypdk+WrgIJqLhGG7sg==}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-V4KtWtQfAFMU7+9/A/VDps/VI8CHd3cYz0L8sgJzz8qK7eY7wI4ruFD82UYIYvW9Z4DtlTfhQcsl4XyPHW5uSg==}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-LBx9LYXvj2CBkMkjLdNAWLwH0MLMin7do2VcVo9kVPibGLkY0BQQut2fv7NVqkXqZ/CrAu9LqDHVV1xHCMpCPw==}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-ABVf3Q0RCu7NcyCCOZQI0pJ3GuSdfSl8EXcy88QtdceIMIoCUdfhsJChZ64L9zVM2aJHjde1Bhn5uqSRcX9ySA==}
@@ -8640,24 +8760,28 @@ packages:
engines: {node: '>= 20'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-Md44bD6veX/PC5iyF8cDVnw4HBIANZepRZZ7a8DQOvkfo5WUBwcp6iAuCUz23u+4SUkhJlD3eL7hNdW8ezd/kA==}
engines: {node: '>= 20'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-tx7us1muwOKAKWao2v/GaafFeQboE6aj88vC6ziN2NCGcRm8gWUhwjzg+YdVB1e4boAtdtma4L43onunI6NS4w==}
engines: {node: '>= 20'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-SJxX60smvHgasZoBy11dX6YRjXJFovwWBoedhbQPOBzgFWBHGB+TVPWB9BxzR7TTxU8FQZAI2AyiNCMzFm8Img==}
engines: {node: '>= 20'}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-jx1+rPhY/5Ympkktd656HBWEBLxP7dH06losBLjjf5vgCODXvi9KhtftWcMIwTFIDqBr7cRnQkdLnAG+IOlGvQ==}
@@ -8712,24 +8836,28 @@ packages:
engines: {node: '>= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
'@takumi-rs/[email protected]':
resolution: {integrity: sha512-4CiEF518wDnujF0fjql2XN6uO+OXl0svy0WgAF2656dCx2gJtWscaHytT2rsQ0ZmoFWE0dyWcDW1g/FBVPvuvA==}
engines: {node: '>= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
'@takumi-rs/[email protected]':
resolution: {integrity: sha512-jm8lTe2E6Tfq2b97GJC31TWK1JAEv+MsVbvL9DCLlYcafgYFlMXDUnOkZFMjlrmh0HcFAYDaBkniNDgIQfXqzg==}
engines: {node: '>= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
'@takumi-rs/[email protected]':
resolution: {integrity: sha512-nbdzQgC4ywzltDDV1fer1cKswwGE+xXZHdDiacdd7RM5XBng209Bmo3j1iv9dsX+4xXhByzCCGbxdWhhHqVXmw==}
engines: {node: '>= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0'}
cpu: [x64]
os: [linux]
+ libc: [musl]
'@takumi-rs/[email protected]':
resolution: {integrity: sha512-kE4F0LRmuhSwiNkFG7dTY9ID8+B7zb97QedyN/IO2fBJmRQDkqCGcip2gloh8YPPhCuKGjCqqqh2L+Tg9PKW7w==}
@@ -9464,51 +9592,61 @@ packages:
resolution: {integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==}
cpu: [loong64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==}
cpu: [loong64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==}
cpu: [ppc64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==}
cpu: [riscv64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==}
cpu: [riscv64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==}
cpu: [s390x]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==}
@@ -13742,48 +13880,56 @@ packages:
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ libc: [glibc]
resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ libc: [musl]
resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
@@ -18694,13 +18840,13 @@ snapshots:
- vue
- ws
dependencies:
'@ag-ui/a2ui-toolkit': 0.0.4
'@ag-ui/client': 0.0.57
'@ag-ui/core': 0.0.53
'@ai-sdk/ui-utils': 1.2.11([email protected])
- '@copilotkit/runtime': 1.63.2(jxv6mwtq5mdjn4pxebnhka7qwi)
+ '@copilotkit/runtime': 1.63.2(5169dbf412b46dd8a4cac6d73cc9c1f3)
fast-json-patch: 3.1.1
@@ -20115,7 +20261,7 @@ snapshots:
'@copilotkit/[email protected]': {}
- '@copilotkit/[email protected](jxv6mwtq5mdjn4pxebnhka7qwi)':
+ '@copilotkit/[email protected](5169dbf412b46dd8a4cac6d73cc9c1f3)':
dependencies:
'@ag-ui/a2ui-middleware': 0.0.10(@ag-ui/[email protected])([email protected])
'@ag-ui/client': 0.0.57
@@ -21739,7 +21885,7 @@ snapshots:
- openai
- ws
- '@langchain/[email protected](bhtnaejseqq2m7qzl44jvsnn2m)':
+ '@langchain/[email protected](034c2039ce40cfd9923293160ef8005c)':
dependencies:
'@babel/code-frame': 7.29.7
'@hono/node-server': 1.19.17([email protected])
@@ -21783,11 +21929,11 @@ snapshots:
dependencies:
- '@langchain/[email protected](bhtnaejseqq2m7qzl44jvsnn2m)':
+ '@langchain/[email protected](034c2039ce40cfd9923293160ef8005c)':
dependencies:
'@babel/code-frame': 7.29.7
'@commander-js/extra-typings': 13.1.0([email protected])
- '@langchain/langgraph-api': 1.4.3(bhtnaejseqq2m7qzl44jvsnn2m)
+ '@langchain/langgraph-api': 1.4.3(034c2039ce40cfd9923293160ef8005c)
chokidar: 4.0.3
commander: 13.1.0
create-langgraph: 1.1.5([email protected])
@@ -22899,7 +23045,7 @@ snapshots:
- rolldown
- unplugin
- '@nuxt/[email protected](77e6ylydnfvqpqxdvwm7dkg7ce)':
+ '@nuxt/[email protected](41b699148a7570ef336847082284397b)':
dependencies:
'@nuxt/devalue': 2.0.2
'@nuxt/kit': 3.21.10([email protected])
@@ -22993,7 +23139,7 @@ snapshots:
rc9: 3.0.1
std-env: 4.2.0
- '@nuxt/[email protected](ecvzqdh5tf262oybfjazhcwuzi)':
+ '@nuxt/[email protected](75be60b7727ba912465a7733945f21b9)':
dependencies:
'@nuxt/kit': 3.21.10([email protected])
'@rollup/plugin-replace': 6.0.3([email protected])
@@ -28139,13 +28285,13 @@ snapshots:
dependencies:
execa: 5.1.1
dependencies:
'@vercel/oidc': 3.6.1
optionalDependencies:
'@ai-sdk/mcp': 1.0.64([email protected])
ai: 7.0.0-beta.178([email protected])
- eve: 0.11.10(oqjwrf4zrwhkmsh6cw25wqbywa)
+ eve: 0.11.10(334bb9546b1c81dc4133f38010d6ba8c)
dependencies:
@@ -30147,7 +30293,7 @@ snapshots:
- [email protected](netxvpgoa72hqc2a7n7pcqhqha):
+ [email protected](91bd0eba1cf83c982119a44cf5cfde79):
dependencies:
@@ -30686,7 +30832,7 @@ snapshots:
transitivePeerDependencies:
- supports-color
dependencies:
debug: 3.2.7
optionalDependencies:
@@ -30708,7 +30854,7 @@ snapshots:
doctrine: 2.1.0
eslint: 9.39.5([email protected])
eslint-import-resolver-node: 0.3.10
hasown: 2.0.4
is-core-module: 2.16.2
is-glob: 4.0.3
@@ -31018,7 +31164,7 @@ snapshots:
- [email protected](oqjwrf4zrwhkmsh6cw25wqbywa):
+ [email protected](334bb9546b1c81dc4133f38010d6ba8c):
dependencies:
ai: 7.0.0-beta.178([email protected])
@@ -35115,10 +35261,10 @@ snapshots:
'@nuxt/kit': 3.21.10([email protected])
- '@nuxt/nitro-server': 3.21.10(77e6ylydnfvqpqxdvwm7dkg7ce)
+ '@nuxt/nitro-server': 3.21.10(41b699148a7570ef336847082284397b)
'@nuxt/schema': 3.21.10
'@nuxt/telemetry': 2.8.0(@nuxt/[email protected]([email protected]))
- '@nuxt/vite-builder': 3.21.10(ecvzqdh5tf262oybfjazhcwuzi)
+ '@nuxt/vite-builder': 3.21.10(75be60b7727ba912465a7733945f21b9)
'@unhead/vue': 2.1.16([email protected]([email protected]))
'@vue/shared': 3.5.40
c12: 3.3.4([email protected])