@elizaos/ui 2.0.0-beta.2 → 2.0.3-beta.3

package/first-run/use-microphone-permission.d.ts

@@ -0,0 +1,17 @@
+import type { PermissionStatus } from "@elizaos/shared";
+export type MicrophonePermissionStatus = PermissionStatus | "unknown";
+export interface MicrophonePermissionState {
+    status: MicrophonePermissionStatus;
+    /** Whether the OS-level request can be re-triggered (false once denied). */
+    canRequest: boolean;
+    /** True while a request is in flight. */
+    requesting: boolean;
+}
+export interface MicrophonePermissionController extends MicrophonePermissionState {
+    /** Prompt the OS for microphone access and reflect the resulting state. */
+    request: () => Promise<void>;
+    /** Open OS settings so a denied permission can be granted manually. */
+    openSettings: () => Promise<void>;
+}
+export declare function useMicrophonePermission(): MicrophonePermissionController;
+//# sourceMappingURL=use-microphone-permission.d.ts.map

package/first-run/use-microphone-permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-microphone-permission.d.ts","sourceRoot":"","sources":["../../../../../src/first-run/use-microphone-permission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAmBxD,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,GAAG,SAAS,CAAC;AAEtE,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,0BAA0B,CAAC;IACnC,4EAA4E;IAC5E,UAAU,EAAE,OAAO,CAAC;IACpB,yCAAyC;IACzC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,8BACf,SAAQ,yBAAyB;IACjC,2EAA2E;IAC3E,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,uEAAuE;IACvE,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AA0CD,wBAAgB,uBAAuB,IAAI,8BAA8B,CAyDxE"}

package/first-run/use-microphone-permission.js

@@ -0,0 +1,106 @@
+import * as React from "react";
+import { client } from "../api/index.js";
+/**
+ * Microphone permission for voice-first onboarding.
+ *
+ * Wraps the cross-platform permission client (`client.requestPermission` /
+ * `client.openPermissionSettings`, which route to Electrobun RPC on desktop,
+ * Capacitor on iOS/Android, and `getUserMedia`/`Notification` on web). When
+ * those client methods are unavailable in the current renderer, it degrades to
+ * a plain `getUserMedia({ audio: true })` probe so the prompt still surfaces.
+ *
+ * None of these paths throw: every failure resolves to a concrete state so the
+ * onboarding UI can always render an actionable affordance.
+ */
+const MICROPHONE = "microphone";
+function hasClientPermissionApi() {
+    return (typeof client.requestPermission === "function" &&
+        typeof client.openPermissionSettings === "function");
+}
+/**
+ * Fallback path when the permission client is unavailable: a bare
+ * `getUserMedia` probe. A granted stream is stopped immediately (we only want
+ * the permission, not the audio). A rejection means denied/blocked.
+ */
+async function probeMicrophoneViaGetUserMedia() {
+    if (typeof navigator === "undefined" ||
+        typeof navigator.mediaDevices?.getUserMedia !== "function") {
+        return "not-applicable";
+    }
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        for (const track of stream.getTracks()) {
+            track.stop();
+        }
+        return "granted";
+    }
+    catch {
+        return "denied";
+    }
+}
+async function openMicrophoneSettingsViaClient() {
+    if (typeof client.openPermissionSettings !== "function")
+        return;
+    try {
+        await client.openPermissionSettings(MICROPHONE);
+    }
+    catch {
+        // Opening OS settings is best-effort; a failure here must not break
+        // onboarding. The user can still grant access through the OS directly.
+    }
+}
+export function useMicrophonePermission() {
+    const [state, setState] = React.useState({
+        status: "unknown",
+        canRequest: true,
+        requesting: false,
+    });
+    const requestingRef = React.useRef(false);
+    const request = React.useCallback(async () => {
+        if (requestingRef.current)
+            return;
+        requestingRef.current = true;
+        setState((current) => ({ ...current, requesting: true }));
+        let status = "unknown";
+        let canRequest = true;
+        if (hasClientPermissionApi()) {
+            try {
+                const result = await client.requestPermission(MICROPHONE);
+                status = result.status;
+                canRequest = result.canRequest;
+            }
+            catch {
+                // The platform permission client failed (older renderer, missing
+                // bridge); fall back to the browser probe rather than surfacing an
+                // error the user cannot act on.
+                status = await probeMicrophoneViaGetUserMedia();
+                canRequest = status !== "denied";
+            }
+        }
+        else {
+            status = await probeMicrophoneViaGetUserMedia();
+            canRequest = status !== "denied";
+        }
+        requestingRef.current = false;
+        setState({ status, canRequest, requesting: false });
+    }, []);
+    const openSettings = React.useCallback(async () => {
+        if (hasClientPermissionApi()) {
+            await openMicrophoneSettingsViaClient();
+            return;
+        }
+        // No OS-settings deep link in this renderer: re-probe so a permission the
+        // user just granted out-of-band is reflected without a manual retry.
+        const status = await probeMicrophoneViaGetUserMedia();
+        setState((current) => ({
+            ...current,
+            status,
+            canRequest: status !== "denied",
+        }));
+    }, []);
+    return {
+        ...state,
+        request,
+        openSettings,
+    };
+}

package/first-run/voice-readiness.d.ts

@@ -0,0 +1,14 @@
+export declare const FIRST_RUN_VOICE_PREPARING_MESSAGE = "Voice input is preparing. You can type while transcription gets ready.";
+export type FirstRunVoiceReadiness = {
+    status: "ready";
+    message: string;
+} | {
+    status: "preparing";
+    message: string;
+} | {
+    status: "unsupported";
+    message: string;
+};
+export declare function resolveFirstRunLocalAgentApiBase(): string;
+export declare function prepareFirstRunVoiceAndTranscription(): Promise<FirstRunVoiceReadiness>;
+//# sourceMappingURL=voice-readiness.d.ts.map

package/first-run/voice-readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-readiness.d.ts","sourceRoot":"","sources":["../../../../../src/first-run/voice-readiness.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,iCAAiC,2EAC4B,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAC9B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C,wBAAgB,gCAAgC,IAAI,MAAM,CAIzD;AAgBD,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,sBAAsB,CAAC,CA2D5F"}

package/first-run/voice-readiness.js

@@ -0,0 +1,78 @@
+import { client } from "../api/index.js";
+import { fetchWithCsrf } from "../api/csrf-client.js";
+import { isAndroid, isDesktopPlatform, isIOS } from "../platform/init.js";
+import { getElizaApiBase, resolveApiUrl } from "../utils/index.js";
+import { isLocalAsrCaptureSupported } from "../voice/local-asr-capture.js";
+import { ANDROID_LOCAL_AGENT_IPC_BASE, IOS_LOCAL_AGENT_IPC_BASE, } from "./mobile-runtime-mode.js";
+const DEFAULT_LOCAL_AGENT_API_BASE = "http://127.0.0.1:31337";
+export const FIRST_RUN_VOICE_PREPARING_MESSAGE = "Voice input is preparing. You can type while transcription gets ready.";
+export function resolveFirstRunLocalAgentApiBase() {
+    if (isIOS)
+        return IOS_LOCAL_AGENT_IPC_BASE;
+    if (isAndroid)
+        return ANDROID_LOCAL_AGENT_IPC_BASE;
+    return getElizaApiBase() ?? DEFAULT_LOCAL_AGENT_API_BASE;
+}
+async function hasPackagedLocalAsrRuntime() {
+    try {
+        const res = await fetchWithCsrf(resolveApiUrl("/api/asr/local-inference/status"), { method: "GET" });
+        if (!res.ok)
+            return false;
+        const body = (await res.json());
+        return body.ready === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function prepareFirstRunVoiceAndTranscription() {
+    if (!isLocalAsrCaptureSupported()) {
+        if (isDesktopPlatform()) {
+            return {
+                status: "preparing",
+                message: "Preparing desktop microphone capture.",
+            };
+        }
+        return {
+            status: "unsupported",
+            message: "Voice input is not available in this renderer.",
+        };
+    }
+    try {
+        const active = await client.getLocalInferenceActive();
+        if (active.status === "ready" && typeof active.modelId === "string") {
+            return active.modelId.trim().length > 0
+                ? { status: "ready", message: "Voice and transcription ready." }
+                : { status: "preparing", message: FIRST_RUN_VOICE_PREPARING_MESSAGE };
+        }
+        if (await hasPackagedLocalAsrRuntime()) {
+            return { status: "ready", message: "Voice and transcription ready." };
+        }
+        if (active.status === "loading") {
+            return {
+                status: "preparing",
+                message: FIRST_RUN_VOICE_PREPARING_MESSAGE,
+            };
+        }
+        const snapshot = await client.getLocalInferenceHub();
+        const installedBundle = snapshot.installed.find((model) => model.source === "eliza-download" && model.bundleRoot);
+        if (installedBundle) {
+            const nextActive = await client.setLocalInferenceActive(installedBundle.id);
+            if (nextActive.status === "ready" &&
+                typeof nextActive.modelId === "string" &&
+                nextActive.modelId.trim().length > 0) {
+                return { status: "ready", message: "Voice and transcription ready." };
+            }
+        }
+        return {
+            status: "preparing",
+            message: FIRST_RUN_VOICE_PREPARING_MESSAGE,
+        };
+    }
+    catch {
+        return {
+            status: "preparing",
+            message: FIRST_RUN_VOICE_PREPARING_MESSAGE,
+        };
+    }
+}

package/genui/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ElizaGenUiAction, ElizaGenUiActionContext, ElizaGenUiActionHandler, ElizaGenUiActionResult } from "./types.js";
+export declare class ElizaGenUiActionError extends Error {
+    readonly action: ElizaGenUiAction;
+    constructor(message: string, action: ElizaGenUiAction);
+}
+export declare function createElizaGenUiPrefixActionHandler(prefixes: readonly string[], handle: (action: ElizaGenUiAction, context: ElizaGenUiActionContext) => Promise<ElizaGenUiActionResult>): ElizaGenUiActionHandler;
+export declare function routeElizaGenUiAction(action: ElizaGenUiAction, context: ElizaGenUiActionContext, handlers: readonly ElizaGenUiActionHandler[]): Promise<ElizaGenUiActionResult>;
+//# sourceMappingURL=actions.d.ts.map

package/genui/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../src/genui/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;gBAEtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB;CAKtD;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,MAAM,EAAE,CACN,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,uBAAuB,KAC7B,OAAO,CAAC,sBAAsB,CAAC,GACnC,uBAAuB,CAOzB;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,uBAAuB,EAChC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,GAC3C,OAAO,CAAC,sBAAsB,CAAC,CAgBjC"}

package/genui/actions.js

@@ -0,0 +1,28 @@
+import { isElizaGenUiActionNameAllowed } from "./catalog.js";
+export class ElizaGenUiActionError extends Error {
+    action;
+    constructor(message, action) {
+        super(message);
+        this.name = "ElizaGenUiActionError";
+        this.action = action;
+    }
+}
+export function createElizaGenUiPrefixActionHandler(prefixes, handle) {
+    return {
+        canHandle(eventName) {
+            return prefixes.some((prefix) => eventName.startsWith(prefix));
+        },
+        handle,
+    };
+}
+export async function routeElizaGenUiAction(action, context, handlers) {
+    const eventName = action.event.name;
+    if (!isElizaGenUiActionNameAllowed(eventName)) {
+        throw new ElizaGenUiActionError(`Generated UI action "${eventName}" is not allowed.`, action);
+    }
+    const handler = handlers.find((candidate) => candidate.canHandle(eventName));
+    if (!handler) {
+        throw new ElizaGenUiActionError(`No generated UI action handler registered for "${eventName}".`, action);
+    }
+    return handler.handle(action, context);
+}

package/genui/catalog.d.ts

@@ -0,0 +1,11 @@
+export declare const ELIZA_GENUI_PRIMITIVE_COMPONENTS: readonly ["Row", "Column", "List", "Text", "Image", "Icon", "Divider", "Button", "TextField", "CheckBox", "Slider", "DateTimeInput", "ChoicePicker", "Card", "Modal", "Tabs"];
+export declare const ELIZA_GENUI_DOMAIN_COMPONENTS: readonly ["ProviderSetupCard", "ModelPicker", "ConnectorSetupCard", "PermissionRequest", "StarterPackStatus", "LaunchDiagnosticsCard", "TraceTimeline", "VoiceLatencyTimeline", "ToolCallTimeline", "GitDiffViewer", "TerminalTranscript", "FileSearchResults", "ModelDownloadStatus"];
+export declare const ELIZA_GENUI_ALLOWED_COMPONENTS: readonly ["Row", "Column", "List", "Text", "Image", "Icon", "Divider", "Button", "TextField", "CheckBox", "Slider", "DateTimeInput", "ChoicePicker", "Card", "Modal", "Tabs", "ProviderSetupCard", "ModelPicker", "ConnectorSetupCard", "PermissionRequest", "StarterPackStatus", "LaunchDiagnosticsCard", "TraceTimeline", "VoiceLatencyTimeline", "ToolCallTimeline", "GitDiffViewer", "TerminalTranscript", "FileSearchResults", "ModelDownloadStatus"];
+export type ElizaGenUiPrimitiveComponent = (typeof ELIZA_GENUI_PRIMITIVE_COMPONENTS)[number];
+export type ElizaGenUiDomainComponent = (typeof ELIZA_GENUI_DOMAIN_COMPONENTS)[number];
+export type ElizaGenUiKnownComponent = (typeof ELIZA_GENUI_ALLOWED_COMPONENTS)[number];
+export declare const ELIZA_GENUI_ALLOWED_ACTION_PREFIXES: readonly ["setup.", "model.", "provider.", "connector.", "runtime.", "capability.", "dynamicView.", "trace.", "voice."];
+export declare function isElizaGenUiKnownComponent(value: string): value is ElizaGenUiKnownComponent;
+export declare function isElizaGenUiPrimitiveComponent(value: string): value is ElizaGenUiPrimitiveComponent;
+export declare function isElizaGenUiActionNameAllowed(eventName: string, prefixes?: readonly string[], names?: readonly string[]): boolean;
+//# sourceMappingURL=catalog.d.ts.map

package/genui/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../../src/genui/catalog.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,+KAiBnC,CAAC;AAEX,eAAO,MAAM,6BAA6B,wRAchC,CAAC;AAEX,eAAO,MAAM,8BAA8B,4bAGjC,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACtC,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpD,MAAM,MAAM,yBAAyB,GACnC,CAAC,OAAO,6BAA6B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,mCAAmC,yHAUtC,CAAC;AAEX,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,GACZ,KAAK,IAAI,wBAAwB,CAEnC;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GACZ,KAAK,IAAI,4BAA4B,CAIvC;AAED,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,SAAS,MAAM,EAAwC,EACjE,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B,OAAO,CAKT"}

package/genui/catalog.js

@@ -0,0 +1,58 @@
+export const ELIZA_GENUI_PRIMITIVE_COMPONENTS = [
+    "Row",
+    "Column",
+    "List",
+    "Text",
+    "Image",
+    "Icon",
+    "Divider",
+    "Button",
+    "TextField",
+    "CheckBox",
+    "Slider",
+    "DateTimeInput",
+    "ChoicePicker",
+    "Card",
+    "Modal",
+    "Tabs",
+];
+export const ELIZA_GENUI_DOMAIN_COMPONENTS = [
+    "ProviderSetupCard",
+    "ModelPicker",
+    "ConnectorSetupCard",
+    "PermissionRequest",
+    "StarterPackStatus",
+    "LaunchDiagnosticsCard",
+    "TraceTimeline",
+    "VoiceLatencyTimeline",
+    "ToolCallTimeline",
+    "GitDiffViewer",
+    "TerminalTranscript",
+    "FileSearchResults",
+    "ModelDownloadStatus",
+];
+export const ELIZA_GENUI_ALLOWED_COMPONENTS = [
+    ...ELIZA_GENUI_PRIMITIVE_COMPONENTS,
+    ...ELIZA_GENUI_DOMAIN_COMPONENTS,
+];
+export const ELIZA_GENUI_ALLOWED_ACTION_PREFIXES = [
+    "setup.",
+    "model.",
+    "provider.",
+    "connector.",
+    "runtime.",
+    "capability.",
+    "dynamicView.",
+    "trace.",
+    "voice.",
+];
+export function isElizaGenUiKnownComponent(value) {
+    return ELIZA_GENUI_ALLOWED_COMPONENTS.includes(value);
+}
+export function isElizaGenUiPrimitiveComponent(value) {
+    return ELIZA_GENUI_PRIMITIVE_COMPONENTS.includes(value);
+}
+export function isElizaGenUiActionNameAllowed(eventName, prefixes = ELIZA_GENUI_ALLOWED_ACTION_PREFIXES, names = []) {
+    return (names.includes(eventName) ||
+        prefixes.some((prefix) => eventName.startsWith(prefix)));
+}

package/genui/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./actions.js";
+export * from "./catalog.js";
+export * from "./renderer.js";
+export * from "./starter-pack-demo.js";
+export * from "./streaming.js";
+export * from "./types.js";
+export * from "./use-ui-stream.js";
+export * from "./validator.js";
+//# sourceMappingURL=index.d.ts.map

package/genui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/genui/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/genui/index.js

@@ -0,0 +1,8 @@
+export * from "./actions.js";
+export * from "./catalog.js";
+export * from "./renderer.js";
+export * from "./starter-pack-demo.js";
+export * from "./streaming.js";
+export * from "./types.js";
+export * from "./use-ui-stream.js";
+export * from "./validator.js";

package/genui/modes.d.ts

@@ -0,0 +1,7 @@
+import type { ElizaGenUiMode, ElizaGenUiModeConfig } from "./types.js";
+export declare const STANDALONE_MODE_PROMPT_RULES: string[];
+export declare const INLINE_MODE_PROMPT_RULES: string[];
+export declare function getModePromptRules(mode: ElizaGenUiMode, customRules?: readonly string[]): string;
+export declare function getModeSystemPrompt(config: ElizaGenUiModeConfig): string;
+export declare function buildCatalogPromptWithMode(catalogPrompt: string, modeConfig?: ElizaGenUiModeConfig): string;
+//# sourceMappingURL=modes.d.ts.map

package/genui/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../../../../src/genui/modes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpE,eAAO,MAAM,4BAA4B,UAQxC,CAAC;AAEF,eAAO,MAAM,wBAAwB,UAQpC,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,cAAc,EACpB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAC9B,MAAM,CAOR;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CASxE;AAED,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,oBAAoB,GAChC,MAAM,CAKR"}

package/genui/modes.js

@@ -0,0 +1,41 @@
+export const STANDALONE_MODE_PROMPT_RULES = [
+    "Output ONLY JSONL patches — no prose, no markdown, no explanations.",
+    "Each line must be a valid JSON Patch (RFC 6902) operation:",
+    '  {"op":"add","path":"...","value":...}',
+    '  {"op":"replace","path":"...","value":...}',
+    '  {"op":"remove","path":"..."}',
+    "Start by setting the root component, then add elements.",
+    "The entire response is a UI spec — there is no conversation.",
+];
+export const INLINE_MODE_PROMPT_RULES = [
+    "Respond conversationally first, then output JSONL patches on their own lines when UI is needed.",
+    "Each JSONL patch line must be a valid JSON Patch (RFC 6902) operation:",
+    '  {"op":"add","path":"...","value":...}',
+    '  {"op":"replace","path":"...","value":...}',
+    '  {"op":"remove","path":"..."}',
+    "Text-only replies are allowed when no UI is needed (greetings, clarifying questions).",
+    "Only include JSONL patches when the response benefits from a rich UI.",
+];
+export function getModePromptRules(mode, customRules) {
+    const baseRules = mode === "standalone"
+        ? STANDALONE_MODE_PROMPT_RULES
+        : INLINE_MODE_PROMPT_RULES;
+    const allRules = customRules ? [...baseRules, ...customRules] : baseRules;
+    return allRules.map((rule, i) => `${i + 1}. ${rule}`).join("\n");
+}
+export function getModeSystemPrompt(config) {
+    const mode = config.mode ?? "standalone";
+    const rules = getModePromptRules(mode, config.customRules);
+    return [
+        `## Generation Mode: ${mode === "standalone" ? "Standalone (UI-only)" : "Inline (conversation + UI)"}`,
+        "",
+        rules,
+        "",
+    ].join("\n");
+}
+export function buildCatalogPromptWithMode(catalogPrompt, modeConfig) {
+    if (!modeConfig) {
+        return catalogPrompt;
+    }
+    return [catalogPrompt, "", getModeSystemPrompt(modeConfig)].join("\n");
+}

package/genui/pipe.d.ts

@@ -0,0 +1,10 @@
+import { pipeJsonRender as officialPipeJsonRender } from "@json-render/core";
+import type { ElizaGenUiPatch, ElizaGenUiSpec, ElizaGenUiSpecStreamPart, ElizaGenUiValidationOptions } from "./types.js";
+export { officialPipeJsonRender as pipeJsonRender1 };
+export declare function pipeJsonRenderLines(input: string): ElizaGenUiSpecStreamPart[];
+export declare function pipeJsonRenderStream(chunks: AsyncIterable<string> | ReadableStream<string>, initialSpec?: ElizaGenUiSpec, validationOptions?: ElizaGenUiValidationOptions): ReadableStream<ElizaGenUiSpecStreamPart>;
+export declare function compilePatchesToSpec(patches: readonly ElizaGenUiPatch[], validationOptions?: ElizaGenUiValidationOptions): {
+    spec: ElizaGenUiSpec | null;
+    errors: readonly string[];
+};
+//# sourceMappingURL=pipe.d.ts.map

package/genui/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../../../../src/genui/pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAIjB,OAAO,EAAE,sBAAsB,IAAI,eAAe,EAAE,CAAC;AA2BrD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,wBAAwB,EAAE,CAsB7E;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,EACtD,WAAW,CAAC,EAAE,cAAc,EAC5B,iBAAiB,CAAC,EAAE,2BAA2B,GAC9C,cAAc,CAAC,wBAAwB,CAAC,CAqE1C;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,iBAAiB,CAAC,EAAE,2BAA2B,GAC9C;IAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAc5D"}

package/genui/pipe.js

@@ -0,0 +1,122 @@
+import { pipeJsonRender as officialPipeJsonRender } from "@json-render/core";
+import { applyElizaGenUiPatch } from "./streaming.js";
+// ── Re-exports ───────────────────────────────────────────────────────
+export { officialPipeJsonRender as pipeJsonRender1 };
+// ── Custom pipe functions (ElizaGenUiSpec-compatible) ────────────────
+const PATCH_OP_RE = /^\s*\{/;
+function tryParsePatchLine(line) {
+    const trimmed = line.trim();
+    if (!PATCH_OP_RE.test(trimmed)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed &&
+            typeof parsed === "object" &&
+            typeof parsed.op === "string" &&
+            typeof parsed.path === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // not JSON
+    }
+    return null;
+}
+export function pipeJsonRenderLines(input) {
+    const parts = [];
+    const textLines = [];
+    for (const line of input.split("\n")) {
+        const patch = tryParsePatchLine(line);
+        if (patch) {
+            if (textLines.length > 0) {
+                parts.push({ type: "text", text: textLines.join("\n") });
+                textLines.length = 0;
+            }
+            parts.push({ type: "spec-patch", patch });
+        }
+        else {
+            textLines.push(line);
+        }
+    }
+    if (textLines.length > 0) {
+        parts.push({ type: "text", text: textLines.join("\n") });
+    }
+    return parts;
+}
+export function pipeJsonRenderStream(chunks, initialSpec, validationOptions) {
+    let currentSpec = initialSpec
+        ? structuredClone(initialSpec)
+        : undefined;
+    let buffer = "";
+    return new ReadableStream({
+        async start(controller) {
+            const iterator = Symbol.asyncIterator in chunks
+                ? chunks[Symbol.asyncIterator]()
+                : chunks.getReader();
+            try {
+                while (true) {
+                    let chunk;
+                    let done;
+                    if ("read" in iterator) {
+                        const result = await iterator.read();
+                        chunk = typeof result.value === "string" ? result.value : "";
+                        done = result.done ?? false;
+                    }
+                    else {
+                        const result = await iterator.next();
+                        chunk = typeof result.value === "string" ? result.value : "";
+                        done = result.done ?? false;
+                    }
+                    if (done)
+                        break;
+                    buffer += chunk;
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        const patch = tryParsePatchLine(line);
+                        if (patch) {
+                            if (currentSpec) {
+                                const result = applyElizaGenUiPatch(currentSpec, [patch], validationOptions);
+                                if (result.ok && result.spec) {
+                                    currentSpec = result.spec;
+                                }
+                            }
+                            controller.enqueue({ type: "spec-patch", patch });
+                        }
+                        else {
+                            controller.enqueue({ type: "text", text: `${line}\n` });
+                        }
+                    }
+                }
+                if (currentSpec) {
+                    controller.enqueue({
+                        type: "spec-complete",
+                        spec: currentSpec,
+                    });
+                }
+            }
+            finally {
+                controller.close();
+                if ("releaseLock" in iterator) {
+                    iterator.releaseLock();
+                }
+            }
+        },
+    });
+}
+export function compilePatchesToSpec(patches, validationOptions) {
+    const initial = {
+        version: "0.1",
+        root: "",
+        components: [],
+    };
+    const result = applyElizaGenUiPatch(initial, patches, validationOptions);
+    if (result.ok) {
+        return { spec: result.spec, errors: [] };
+    }
+    return {
+        spec: null,
+        errors: result.errors.map((e) => e.message),
+    };
+}

package/genui/renderer.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { ElizaGenUiRendererProps } from "./types.js";
+export declare function ElizaGenUiRenderer({ spec, actionHandlers, context, devMode, className, onActionError, }: ElizaGenUiRendererProps): React.ReactElement | null;
+//# sourceMappingURL=renderer.d.ts.map

package/genui/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../../../src/genui/renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAS/B,OAAO,KAAK,EAKV,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAuXjB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,cAAmB,EACnB,OAAY,EACZ,OAAe,EACf,SAAS,EACT,aAAa,GACd,EAAE,uBAAuB,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CAmDrD"}