@elizaos/ui 2.0.3-beta.2 → 2.0.3-beta.4

package/components/chat/message-parser-helpers.js

@@ -0,0 +1,490 @@
+import { stripAssistantStageDirections } from "@elizaos/shared";
+import { parsePermissionRequestFromText, } from "../composites/chat/permission-card.helpers.js";
+import { paramsToSchema } from "../pages/plugin-list-utils.js";
+import { getInlineWidgets } from "./widgets/inline-registry.js";
+/** Reject prototype-pollution keys that should never be traversed or rendered. */
+export const BLOCKED_IDS = new Set(["__proto__", "constructor", "prototype"]);
+export const SAFE_PLUGIN_ID_RE = /^[\w-]+$/;
+export function createSafeRecord() {
+    return Object.create(null);
+}
+export function sanitizePatchValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizePatchValue(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const safe = createSafeRecord();
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (BLOCKED_IDS.has(key))
+            continue;
+        safe[key] = sanitizePatchValue(nestedValue);
+    }
+    return safe;
+}
+export function isSafeNormalizedPluginId(id) {
+    return !BLOCKED_IDS.has(id) && SAFE_PLUGIN_ID_RE.test(id);
+}
+// ── Detection ───────────────────────────────────────────────────────
+export const CONFIG_RE = /\[CONFIG:([@\w][\w@./:-]*)\]/g;
+export const FENCED_JSON_RE = /```(?:json)?\s*\n([\s\S]*?)```/g;
+/**
+ * Any fenced code block ```` ```lang\n…``` ````. Captures the (optional)
+ * language tag and the body. Detected after the UiSpec/patch passes so a fenced
+ * UiSpec JSON is rendered as an interactive widget, not raw code; overlapping
+ * regions are dropped before this pass claims them.
+ */
+export const FENCED_CODE_RE = /```([^\n`]*)\n([\s\S]*?)```/g;
+/**
+ * Inline `code` spans inside otherwise plain prose. Backticked runs that contain
+ * a newline are excluded (those are fenced blocks, handled above), and the body
+ * must be non-empty so a stray pair of backticks isn't lifted out.
+ */
+export const INLINE_CODE_RE = /`([^`\n]+)`/g;
+export const HIDDEN_TAG_BLOCK_RE = /<(think|analysis|reasoning|tool_calls?|tools?)\b[^>]*>[\s\S]*?(?:<\/\1>|$)/gi;
+/**
+ * Strip trailing partial hidden tags at the end of a streaming text chunk.
+ * During streaming, the buffer may end mid-tag (e.g. `"Hello<thi"`,
+ * `"Hello</respon"`, or just `"Hello<"`).  These fragments are not
+ * user-facing content and must be hidden from both the display and voice
+ * pipelines.
+ */
+export const TRAILING_PARTIAL_TAG_RE = /<\/?[a-zA-Z][^>]*$|<\/?$/s;
+export function normalizeDisplayText(text) {
+    // Bound input length to keep the regex passes linear in adversarial cases.
+    const MAX_DISPLAY_LEN = 200_000;
+    let normalized = text.length > MAX_DISPLAY_LEN ? text.slice(0, MAX_DISPLAY_LEN) : text;
+    // Hide hidden reasoning/tool blocks from chat bubbles.
+    normalized = normalized.replace(HIDDEN_TAG_BLOCK_RE, " ");
+    // During streaming, a chunk may end mid-tag (e.g. "<thi").
+    // Strip any unterminated opening or closing tag at the very end so the
+    // user never sees hidden-tag fragments while tokens arrive.
+    normalized = normalized.replace(TRAILING_PARTIAL_TAG_RE, "");
+    normalized = stripAssistantStageDirections(normalized);
+    return normalized.trim();
+}
+export function tryParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+export function isUiSpec(obj) {
+    if (!obj || typeof obj !== "object")
+        return false;
+    const c = obj;
+    return (typeof c.root === "string" &&
+        typeof c.elements === "object" &&
+        c.elements !== null);
+}
+// ── JSONL patch support (Chat Mode) ─────────────────────────────────
+/**
+ * Quick pre-check: does this line look like a JSON patch object?
+ * Handles both compact `{"op":` and spaced `{ "op":` formats.
+ */
+export function looksLikePatch(trimmed) {
+    if (!trimmed.startsWith("{"))
+        return false;
+    return trimmed.includes('"op"') && trimmed.includes('"path"');
+}
+/** Try to parse a single line as an RFC 6902 JSON Patch operation. */
+export function tryParsePatch(line) {
+    const t = line.trim();
+    if (!looksLikePatch(t))
+        return null;
+    try {
+        const obj = JSON.parse(t);
+        if (typeof obj.op === "string" && typeof obj.path === "string")
+            return obj;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Apply a list of RFC 6902 patches to build a UiSpec.
+ *
+ * Only handles the paths the catalog emits:
+ *   /root              → spec.root
+ *   /elements/<id>     → spec.elements[id]
+ *   /state/<key>       → spec.state[key]
+ *   /state             → spec.state (whole object)
+ */
+export function compilePatches(patches) {
+    const spec = { elements: {}, state: createSafeRecord() };
+    for (const patch of patches) {
+        if (patch.op !== "add" && patch.op !== "replace")
+            continue;
+        const { path, value } = patch;
+        const parts = path.split("/").filter(Boolean);
+        if (parts.length === 0)
+            continue;
+        if (parts[0] === "root" && parts.length === 1) {
+            spec.root = value;
+        }
+        else if (parts[0] === "elements" && parts.length === 2) {
+            spec.elements[parts[1]] = value;
+        }
+        else if (parts[0] === "state" && parts.length === 1) {
+            const nextState = sanitizePatchValue(value);
+            spec.state =
+                nextState && typeof nextState === "object" && !Array.isArray(nextState)
+                    ? nextState
+                    : createSafeRecord();
+        }
+        else if (parts[0] === "state" && parts.length >= 2) {
+            // Nested state path: /state/key or /state/key/subkey
+            let cursor = spec.state;
+            let blockedPath = false;
+            for (let i = 1; i < parts.length - 1; i++) {
+                const k = parts[i];
+                if (BLOCKED_IDS.has(k)) {
+                    blockedPath = true;
+                    break;
+                }
+                if (!cursor[k] ||
+                    typeof cursor[k] !== "object" ||
+                    Array.isArray(cursor[k])) {
+                    cursor[k] = createSafeRecord();
+                }
+                cursor = cursor[k];
+            }
+            if (blockedPath)
+                continue;
+            const leaf = parts[parts.length - 1];
+            if (BLOCKED_IDS.has(leaf))
+                continue;
+            cursor[leaf] = sanitizePatchValue(value);
+        }
+    }
+    return isUiSpec(spec) ? spec : null;
+}
+/**
+ * Scan `text` for blocks of consecutive JSONL patch lines and return
+ * their character regions plus the compiled UiSpec.
+ *
+ * A patch block is a run of lines where each non-empty line parses as a
+ * valid PatchOp. A single empty line between patch lines is allowed.
+ */
+export function findPatchRegions(text) {
+    const results = [];
+    const lines = text.split("\n");
+    let blockStart = -1;
+    let blockEnd = 0;
+    let patches = [];
+    let rawLines = [];
+    let pos = 0;
+    const flush = () => {
+        if (patches.length >= 1) {
+            const spec = compilePatches(patches);
+            if (spec) {
+                results.push({
+                    start: blockStart,
+                    end: blockEnd,
+                    spec,
+                    raw: rawLines.join("\n"),
+                });
+            }
+        }
+        blockStart = -1;
+        patches = [];
+        rawLines = [];
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // +1 for the newline that split() consumed (except the very last line)
+        const lineLen = line.length + (i < lines.length - 1 ? 1 : 0);
+        const trimmed = line.trim();
+        if (looksLikePatch(trimmed)) {
+            const patch = tryParsePatch(trimmed);
+            if (patch) {
+                if (blockStart === -1)
+                    blockStart = pos;
+                patches.push(patch);
+                rawLines.push(line);
+                blockEnd = pos + lineLen;
+                pos += lineLen;
+                continue;
+            }
+        }
+        // Empty line: peek ahead to see if the next non-empty line is a patch
+        if (trimmed.length === 0 && blockStart !== -1) {
+            const nextPatch = lines.slice(i + 1).find((l) => l.trim().length > 0);
+            if (nextPatch && tryParsePatch(nextPatch) !== null) {
+                // Allow the gap and keep going
+                pos += lineLen;
+                continue;
+            }
+        }
+        // Non-patch content — flush any open block
+        if (blockStart !== -1)
+            flush();
+        pos += lineLen;
+    }
+    if (blockStart !== -1)
+        flush();
+    return results;
+}
+/**
+ * Split a plain-text run into alternating prose and inline `code` parts so the
+ * renderer can wrap backticked spans in the code primitive while keeping them in
+ * the flow of the sentence. Empty backtick pairs (` `` `) are treated as prose.
+ * Pure + synchronous so it unit-tests without the DOM.
+ */
+export function splitInlineCode(text) {
+    const parts = [];
+    let cursor = 0;
+    INLINE_CODE_RE.lastIndex = 0;
+    let match = INLINE_CODE_RE.exec(text);
+    while (match !== null) {
+        const code = match[1];
+        if (code.trim().length > 0) {
+            if (match.index > cursor) {
+                parts.push({ kind: "text", text: text.slice(cursor, match.index) });
+            }
+            parts.push({ kind: "code", code });
+            cursor = match.index + match[0].length;
+        }
+        match = INLINE_CODE_RE.exec(text);
+    }
+    if (cursor < text.length) {
+        parts.push({ kind: "text", text: text.slice(cursor) });
+    }
+    if (parts.length === 0)
+        parts.push({ kind: "text", text });
+    return parts;
+}
+export function parseSegments(text, analysisMode) {
+    // If analysis mode is enabled, we parse the raw text to extract XML blocks,
+    // otherwise we use the normalized text which strips them.
+    const targetText = analysisMode ? text : normalizeDisplayText(text);
+    if (!targetText)
+        return [{ kind: "text", text: "" }];
+    const permissionRequest = analysisMode
+        ? null
+        : parsePermissionRequestFromText(targetText);
+    if (permissionRequest) {
+        const segments = [];
+        if (permissionRequest.display.trim()) {
+            segments.push({ kind: "text", text: permissionRequest.display });
+        }
+        segments.push({ kind: "permission", payload: permissionRequest.payload });
+        return segments;
+    }
+    // Build a list of match regions sorted by position
+    const regions = [];
+    if (analysisMode) {
+        const XML_RE = /<(thought|analysis|reasoning|tool_calls?|tools?|action|providers?|response|text)\b[^>]*>([\s\S]*?)(?:<\/\1>|$)/gi;
+        let m = XML_RE.exec(targetText);
+        while (m !== null) {
+            regions.push({
+                start: m.index,
+                end: m.index + m[0].length,
+                segment: {
+                    kind: "analysis-xml",
+                    tag: m[1].toLowerCase(),
+                    content: m[2],
+                },
+            });
+            m = XML_RE.exec(targetText);
+        }
+    }
+    // 1. Find [CONFIG:pluginId] markers
+    CONFIG_RE.lastIndex = 0;
+    let m = CONFIG_RE.exec(targetText);
+    while (m !== null) {
+        regions.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            segment: { kind: "config", pluginId: m[1] },
+        });
+        m = CONFIG_RE.exec(targetText);
+    }
+    // 1b. Registry-driven inline widgets (choice/followups/form/task and any
+    // plugin-registered marker). Each widget owns its parsing semantics; we only
+    // collect the regions and tag them with the widget kind for render dispatch.
+    for (const widget of getInlineWidgets()) {
+        for (const match of widget.parse(targetText)) {
+            regions.push({
+                start: match.start,
+                end: match.end,
+                segment: {
+                    kind: "widget",
+                    widgetKind: widget.kind,
+                    data: match.data,
+                },
+            });
+        }
+    }
+    // 2. Find fenced JSON that is a UiSpec (Generate Mode / legacy format)
+    FENCED_JSON_RE.lastIndex = 0;
+    m = FENCED_JSON_RE.exec(targetText);
+    while (m !== null) {
+        const json = m[1].trim();
+        const parsed = tryParse(json);
+        if (parsed && isUiSpec(parsed)) {
+            regions.push({
+                start: m.index,
+                end: m.index + m[0].length,
+                segment: { kind: "ui-spec", spec: parsed, raw: json },
+            });
+        }
+        m = FENCED_JSON_RE.exec(targetText);
+    }
+    // 3. Find inline JSONL patch blocks (Chat Mode)
+    for (const patch of findPatchRegions(targetText)) {
+        // Skip if this region overlaps with an already-found fenced block
+        const overlaps = regions.some((r) => patch.start < r.end && patch.end > r.start);
+        if (!overlaps) {
+            regions.push({
+                start: patch.start,
+                end: patch.end,
+                segment: { kind: "ui-spec", spec: patch.spec, raw: patch.raw },
+            });
+        }
+    }
+    // 4. Find fenced code blocks. Runs after the UiSpec/patch passes so a fenced
+    // UiSpec JSON renders as an interactive widget, not raw code; any fence that
+    // overlaps an already-claimed region (UiSpec, config marker, …) is dropped.
+    // Inline `code` is NOT lifted to a segment here — it stays in the text and is
+    // rendered inline by `MessageTextBody` so it keeps its place in the sentence;
+    // only block code gets the CodeBlock copy affordance.
+    const overlapsExisting = (start, end) => regions.some((r) => start < r.end && end > r.start);
+    FENCED_CODE_RE.lastIndex = 0;
+    m = FENCED_CODE_RE.exec(targetText);
+    while (m !== null) {
+        const start = m.index;
+        const end = m.index + m[0].length;
+        const lang = m[1].trim();
+        const code = m[2].replace(/\n$/, "");
+        if (code.length > 0 && !overlapsExisting(start, end)) {
+            regions.push({
+                start,
+                end,
+                segment: {
+                    kind: "code",
+                    code,
+                    inline: false,
+                    ...(lang ? { lang } : {}),
+                },
+            });
+        }
+        m = FENCED_CODE_RE.exec(targetText);
+    }
+    // No special content found — return plain text
+    if (regions.length === 0) {
+        return [{ kind: "text", text: targetText }];
+    }
+    // Sort by start position, then interleave with text segments
+    regions.sort((a, b) => a.start - b.start);
+    const segments = [];
+    let cursor = 0;
+    for (const r of regions) {
+        // Skip overlapping regions
+        if (r.start < cursor)
+            continue;
+        // Push preceding text
+        if (r.start > cursor) {
+            const t = targetText.slice(cursor, r.start);
+            if (t.trim())
+                segments.push({ kind: "text", text: t });
+        }
+        segments.push(r.segment);
+        cursor = r.end;
+    }
+    // Trailing text
+    if (cursor < targetText.length) {
+        const t = targetText.slice(cursor);
+        if (t.trim())
+            segments.push({ kind: "text", text: t });
+    }
+    return segments;
+}
+/**
+ * Render a conversation as a plain-text transcript for "copy conversation".
+ * Each turn becomes a `Speaker: text` block (blank line between turns), using
+ * the display name for the speaker (the agent name for assistant turns, "You"
+ * for the user). Empty/whitespace-only turns are skipped. Pure + DOM-free so it
+ * unit-tests without React and both chat surfaces share one definition.
+ */
+export function conversationTranscriptText(messages, options = {}) {
+    const agentName = options.agentName?.trim() || "Assistant";
+    const userName = options.userName?.trim() || "You";
+    return messages
+        .map((message) => {
+        const text = message.text.trim();
+        if (!text)
+            return "";
+        const speaker = message.role === "assistant" ? agentName : userName;
+        return `${speaker}: ${text}`;
+    })
+        .filter((line) => line.length > 0)
+        .join("\n\n");
+}
+// ── InlinePluginConfig helpers ──────────────────────────────────────
+/** Normalize plugin ID: strip @scope/plugin- prefix so both "discord" and "@elizaos/plugin-discord" resolve. */
+export function normalizePluginId(id) {
+    return id.replace(/^@[^/]+\/plugin-/, "");
+}
+export function buildInlinePluginConfigModel(plugin, values) {
+    const pluginParams = plugin?.parameters ?? [];
+    const hasConfigurableParams = pluginParams.length > 0;
+    if (!hasConfigurableParams || !plugin?.id) {
+        return {
+            hasConfigurableParams: false,
+            hints: {},
+            mergedValues: values,
+            schema: null,
+            setKeys: new Set(),
+        };
+    }
+    const auto = paramsToSchema(pluginParams, plugin.id);
+    if (plugin.configUiHints) {
+        for (const [key, serverHint] of Object.entries(plugin.configUiHints)) {
+            auto.hints[key] = { ...auto.hints[key], ...serverHint };
+        }
+    }
+    const initialValues = {};
+    const setKeys = new Set();
+    for (const param of pluginParams) {
+        if (param.isSet) {
+            setKeys.add(param.key);
+        }
+        if (param.isSet && !param.sensitive && param.currentValue != null) {
+            initialValues[param.key] = param.currentValue;
+        }
+    }
+    for (const [key, value] of Object.entries(values)) {
+        if (value != null && value !== "") {
+            setKeys.add(key);
+        }
+    }
+    return {
+        hasConfigurableParams: true,
+        hints: auto.hints,
+        mergedValues: { ...initialValues, ...values },
+        schema: auto.schema,
+        setKeys,
+    };
+}
+// ── SensitiveRequestBlock helpers ───────────────────────────────────
+export function sensitiveRequestStatusLabel(status) {
+    switch (status) {
+        case "saved":
+        case "submitted":
+        case "fulfilled":
+            return "Saved";
+        case "expired":
+            return "Expired";
+        case "cancelled":
+            return "Cancelled";
+        case "failed":
+            return "Failed";
+        default:
+            return "Pending";
+    }
+}

package/components/chat/widgets/ChoiceWidget.js

@@ -44,7 +44,7 @@ export function ChoiceWidget({ id, scope, options, onChoose, allowCustom = false
                 return (_jsx(Button, { type: "button", variant: variant, size: "sm", disabled: selected !== null, "aria-label": option.label, "aria-pressed": isSelected, "data-testid": `choice-${option.value}`, className: cancel
                         ? "h-7 px-3 text-xs text-muted hover:text-txt disabled:opacity-40"
                         : "h-7 px-3 text-xs disabled:opacity-40", onClick: () => handleChoose(option), children: isSelected ? (_jsxs("span", { className: "inline-flex items-center gap-1", children: [_jsx(Check, { className: "h-3.5 w-3.5", "aria-hidden": true }), _jsx("span", { children: option.label })] })) : (option.label) }, option.value));
-            }), allowCustom && !selected ? (customMode ? (_jsxs("span", { className: "inline-flex items-center gap-1", children: [_jsx("input", { type: "text", "aria-label": "Your own answer", "data-testid": "choice-custom-input", value: customText, placeholder: "Type your answer\u2026", className: "h-7 min-w-40 rounded-md border border-border bg-transparent px-2 text-xs outline-none focus:border-accent", onChange: (e) => setCustomText(e.currentTarget.value), onKeyDown: (e) => {
+            }), allowCustom && !selected ? (customMode ? (_jsxs("span", { className: "inline-flex items-center gap-1", children: [_jsx("input", { type: "text", "aria-label": "Your own answer", "data-testid": "choice-custom-input", value: customText, placeholder: "Type your answer\u2026", className: "h-7 min-w-40 rounded-md border border-border bg-transparent px-2 text-xs outline-none ", onChange: (e) => setCustomText(e.currentTarget.value), onKeyDown: (e) => {
                             if (e.key === "Enter") {
                                 e.preventDefault();
                                 submitCustom();

package/components/chat/widgets/agent-orchestrator-accounts-view.d.ts

@@ -1,6 +1,6 @@
-import type { AccountsListResponse } from "../../../api/client-agent";
-import type { OrchestratorAccountOverview, OrchestratorRoomRosterOverview } from "../../../api/client-types-cloud";
-import type { TranslateFn } from "../../../types";
+import type { AccountsListResponse } from "../../../api/client-agent.js";
+import type { OrchestratorAccountOverview, OrchestratorRoomRosterOverview } from "../../../api/client-types-cloud.js";
+import type { TranslateFn } from "../../../types/index.js";
 export declare const fallbackTranslate: TranslateFn;
 export interface OrchestratorAccountsViewProps {
     accounts: AccountsListResponse | null;

package/components/chat/widgets/agent-orchestrator.d.ts

@@ -15,6 +15,6 @@
  * reverse coupling we don't want. The widget is owned by the app shell; the
  * plugin just provides the backend capabilities it consumes.
  */
-import type { ChatSidebarWidgetDefinition } from "./types";
+import type { ChatSidebarWidgetDefinition } from "./types.js";
 export declare const AGENT_ORCHESTRATOR_PLUGIN_WIDGETS: ChatSidebarWidgetDefinition[];
 //# sourceMappingURL=agent-orchestrator.d.ts.map

package/components/chat/widgets/agent-orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-orchestrator.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/agent-orchestrator.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAiDH,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,SAAS,CAAC;AAmoBjB,eAAO,MAAM,iCAAiC,EAAE,2BAA2B,EAuBxE,CAAC"}
+{"version":3,"file":"agent-orchestrator.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/agent-orchestrator.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAmDH,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,SAAS,CAAC;AA8qBjB,eAAO,MAAM,iCAAiC,EAAE,2BAA2B,EAuBxE,CAAC"}