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

package/voice/voice-selftest/voice-workbench-player.js

@@ -0,0 +1,401 @@
+/**
+ * Multi-turn voice SCENARIO player — the headful half of the Voice Workbench
+ * (#8785). Where {@link runVoiceSelfTest} drives ONE phrase through the real
+ * client pipeline, this drives an ordered {@link VoiceScenario} turn-by-turn
+ * through the SAME real production functions (transcribeLocalInferenceWav,
+ * ElizaClient.sendConversationMessageStream, a real TTS fetch +
+ * AudioContext.decodeAudioData), honouring injected pauses and scoring every
+ * turn against the scenario's ground truth (expected transcript, respond
+ * decision, speaker label, entity).
+ *
+ * Reused by:
+ *   - the in-app voice workbench screen (?shellMode=voice-workbench)
+ *   - the web / android / desktop e2e lanes (they navigate to that screen and
+ *     scrape `window.__voiceWorkbench(scenario)` / the DOM-mirrored report).
+ *
+ * Honesty contract (identical to the self-test): a turn whose backend / corpus
+ * artifact is genuinely absent on this host reports `skipped` — NEVER `pass` —
+ * so CI can tell "can't run here" from "verified working" and never false-green.
+ *
+ * Scenario type: the canonical `VoiceScenario` schema lives in
+ * `@elizaos/plugin-local-inference` (`src/services/voice/voice-scenario.ts`).
+ * That plugin depends inward on `@elizaos/ui`; importing it back here would
+ * invert the dependency direction, so we mirror the exact transport shape as a
+ * local structural type. The plugin's `validateVoiceScenario` remains the single
+ * source of truth for cross-field validity; the player only reads the fields it
+ * drives and never re-implements scenario validation.
+ */
+import { wordErrorRate } from "@elizaos/shared/voice-wer";
+import { fetchWithCsrf } from "../../api/csrf-client.js";
+import { resolveApiUrl } from "../../utils/index.js";
+import { isLocalInferenceAsrReady, transcribeLocalInferenceWav, } from "../local-asr-transcribe.js";
+import { now, sleep } from "./timing.js";
+/** The expected ASR reference for a turn (explicit override or its text). */
+function turnReference(turn) {
+    return (turn.expectedTranscript ?? turn.text ?? "").trim();
+}
+/** Expected diarization label for a turn (explicit override or speaker). */
+function turnSpeakerLabel(turn) {
+    return (turn.expectedSpeakerLabel ?? turn.speaker).trim();
+}
+/**
+ * Peak + RMS amplitude across every channel of a decoded buffer. A buffer of
+ * pure silence decodes fine and reports a positive `duration`, so duration
+ * alone never proves the TTS produced audible sound — these levels do.
+ */
+function measureBufferLevel(buffer) {
+    let peak = 0;
+    let sumSquares = 0;
+    let count = 0;
+    for (let channel = 0; channel < buffer.numberOfChannels; channel += 1) {
+        const data = buffer.getChannelData(channel);
+        for (let i = 0; i < data.length; i += 1) {
+            const v = Math.abs(data[i] ?? 0);
+            if (v > peak)
+                peak = v;
+            sumSquares += v * v;
+            count += 1;
+        }
+    }
+    return { peak, rms: count > 0 ? Math.sqrt(sumSquares / count) : 0 };
+}
+/** Decode + amplitude-check a synthesized reply clip; "" reply yields no clip. */
+async function synthesizeReply(opts, reply) {
+    const res = await fetchWithCsrf(resolveApiUrl(opts.ttsRoute), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "audio/*" },
+        body: JSON.stringify({ text: reply, ...(opts.ttsExtraBody ?? {}) }),
+        signal: opts.signal,
+    });
+    if (!res.ok) {
+        return {
+            ok: false,
+            detail: { ttsStatus: res.status },
+            error: `TTS ${opts.ttsRoute} returned ${res.status}`,
+        };
+    }
+    const bytes = await res.arrayBuffer();
+    if (bytes.byteLength === 0) {
+        return {
+            ok: false,
+            detail: { audioBytes: 0 },
+            error: "TTS returned empty audio",
+        };
+    }
+    const audioBuffer = await opts.audioCtx.decodeAudioData(bytes.slice(0));
+    const { peak, rms } = measureBufferLevel(audioBuffer);
+    // Require real signal, not just a positive duration: a silent (all-zero)
+    // buffer decodes fine and would otherwise false-green.
+    const nonSilent = peak >= 0.02 && rms >= 1e-4;
+    const ok = audioBuffer.duration > 0 && nonSilent;
+    return {
+        ok,
+        detail: {
+            audioBytes: bytes.byteLength,
+            durationSec: Number(audioBuffer.duration.toFixed(3)),
+            peak: Number(peak.toFixed(4)),
+            rms: Number(rms.toFixed(5)),
+        },
+        error: ok
+            ? undefined
+            : !nonSilent
+                ? `TTS audio is silent (peak=${peak.toFixed(4)}, rms=${rms.toFixed(5)})`
+                : "decoded audio has zero duration",
+    };
+}
+/**
+ * Drive ONE scenario turn through the real client pipeline:
+ *   ASR (turn audio -> transcript)
+ *   SEND (transcript -> agent reply over real SSE; reply "" == "did not respond")
+ *   TTS (reply text -> decodable audio; only when the agent responded)
+ * then score the respond decision + transcript WER against ground truth.
+ */
+async function runTurn(opts, turn, index, conversationId) {
+    const t0 = now();
+    const expectedTranscript = turnReference(turn);
+    const expectedSpeakerLabel = turnSpeakerLabel(turn);
+    const werTolerance = opts.werTolerance ?? 0.34;
+    let wav;
+    try {
+        wav = await opts.resolveTurnWav(turn, index);
+    }
+    catch (error) {
+        // No corpus clip for this turn on this host — skip, never pass.
+        return {
+            index,
+            speaker: turn.speaker,
+            expectedSpeakerLabel,
+            predictedSpeakerLabel: null,
+            status: "skipped",
+            responded: false,
+            expectRespond: turn.expectRespond,
+            transcript: "",
+            expectedTranscript,
+            reply: "",
+            durationMs: Math.round(now() - t0),
+            detail: { reason: "turn audio clip not available on this host" },
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    let predictedSpeakerLabel = null;
+    let speakerAttributionRan = false;
+    try {
+        if (opts.resolvePredictedSpeakerLabel) {
+            const label = await opts.resolvePredictedSpeakerLabel(turn, index, wav);
+            predictedSpeakerLabel = label?.trim() || null;
+            speakerAttributionRan = predictedSpeakerLabel !== null;
+        }
+    }
+    catch (error) {
+        return {
+            index,
+            speaker: turn.speaker,
+            expectedSpeakerLabel,
+            predictedSpeakerLabel: null,
+            status: "fail",
+            responded: false,
+            expectRespond: turn.expectRespond,
+            transcript: "",
+            expectedTranscript,
+            reply: "",
+            durationMs: Math.round(now() - t0),
+            detail: { stage: "speaker-attribution" },
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const speakerLabelOk = !speakerAttributionRan || predictedSpeakerLabel === expectedSpeakerLabel;
+    let transcript = "";
+    try {
+        const result = await transcribeLocalInferenceWav(wav, {
+            signal: opts.signal,
+        });
+        transcript = result.text;
+    }
+    catch (error) {
+        return {
+            index,
+            speaker: turn.speaker,
+            expectedSpeakerLabel,
+            predictedSpeakerLabel,
+            status: "fail",
+            responded: false,
+            expectRespond: turn.expectRespond,
+            transcript: "",
+            expectedTranscript,
+            reply: "",
+            durationMs: Math.round(now() - t0),
+            detail: { stage: "asr" },
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const wer = expectedTranscript
+        ? wordErrorRate(expectedTranscript, transcript)
+        : 0;
+    const transcriptOk = wer <= werTolerance;
+    // SEND: the same conversation across turns so context (and the respond
+    // decision) carries forward exactly as it does in a real voice session.
+    let reply = "";
+    let completed = false;
+    let agentName = "";
+    let noResponseReason;
+    try {
+        const send = await opts.client.sendConversationMessageStream(conversationId, transcript, () => { }, "VOICE_DM", opts.signal);
+        reply = (send.text ?? "").trim();
+        completed = send.completed;
+        agentName = send.agentName;
+        noResponseReason = send.noResponseReason;
+    }
+    catch (error) {
+        return {
+            index,
+            speaker: turn.speaker,
+            expectedSpeakerLabel,
+            predictedSpeakerLabel,
+            status: "fail",
+            responded: false,
+            expectRespond: turn.expectRespond,
+            transcript,
+            expectedTranscript,
+            reply: "",
+            durationMs: Math.round(now() - t0),
+            detail: { stage: "send", wer: Number(wer.toFixed(3)) },
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const responded = completed && reply.length > 0;
+    const respondDecisionOk = responded === turn.expectRespond;
+    // TTS only runs when the agent actually replied — a no-respond turn has
+    // nothing to synthesize, and that absence is correct, not a failure.
+    let ttsDetail = {};
+    let ttsOk = true;
+    let ttsError;
+    if (responded) {
+        try {
+            const tts = await synthesizeReply(opts, reply);
+            ttsDetail = tts.detail;
+            ttsOk = tts.ok;
+            ttsError = tts.error;
+        }
+        catch (error) {
+            ttsOk = false;
+            ttsError = error instanceof Error ? error.message : String(error);
+        }
+    }
+    // Inject this turn's silent pauses AFTER the round-trip so the next turn is
+    // separated by the scenario's declared gap (barge-in / EOT timing).
+    if (turn.pausesMs?.length) {
+        for (const ms of turn.pausesMs) {
+            if (opts.signal?.aborted)
+                break;
+            await sleep(Math.max(0, Math.min(ms, 2_000)));
+        }
+    }
+    const ok = transcriptOk &&
+        respondDecisionOk &&
+        ttsOk &&
+        (!speakerAttributionRan || speakerLabelOk);
+    const detail = {
+        transcript,
+        expectedTranscript,
+        wer: Number(wer.toFixed(3)),
+        werTolerance,
+        responded,
+        expectRespond: turn.expectRespond,
+        respondDecisionOk,
+        predictedSpeakerLabel: predictedSpeakerLabel ?? "",
+        expectedSpeakerLabel,
+        speakerLabelOk,
+        speakerAttributionRan,
+        completed,
+        agentName,
+        ...ttsDetail,
+    };
+    if (noResponseReason)
+        detail.noResponseReason = noResponseReason;
+    if (turn.pausesMs?.length) {
+        detail.pausesMs = turn.pausesMs.join(",");
+    }
+    if (turn.expectedEntity)
+        detail.expectedEntity = turn.expectedEntity;
+    return {
+        index,
+        speaker: turn.speaker,
+        expectedSpeakerLabel,
+        predictedSpeakerLabel,
+        status: ok ? "pass" : "fail",
+        responded,
+        expectRespond: turn.expectRespond,
+        transcript,
+        expectedTranscript,
+        reply,
+        durationMs: Math.round(now() - t0),
+        detail,
+        error: ok
+            ? undefined
+            : !transcriptOk
+                ? `ASR WER ${wer.toFixed(3)} exceeds tolerance ${werTolerance}`
+                : !respondDecisionOk
+                    ? `respond decision: got ${responded}, expected ${turn.expectRespond}`
+                    : speakerAttributionRan && !speakerLabelOk
+                        ? `speaker label: got ${predictedSpeakerLabel ?? "null"}, expected ${expectedSpeakerLabel}`
+                        : (ttsError ?? "turn failed"),
+    };
+}
+export function scoreWorkbenchDiarization(turns, maxDer = 0.2) {
+    const ran = turns.filter((turn) => turn.status !== "skipped");
+    // A null prediction means no attribution model ran on this turn (no diarizer
+    // available on this host / scenario). Such turns are UNATTRIBUTED — excluded
+    // from DER, never scored as a confusion. The gate reports `skipped` (evaluated
+    // === false) when nothing was attributed, never a false pass and never a
+    // spurious failure that would block a diarizer-less host (#9147, #9427).
+    const attributed = ran.filter((turn) => turn.predictedSpeakerLabel !== null);
+    let confusions = 0;
+    for (const turn of attributed) {
+        if (turn.predictedSpeakerLabel !== turn.expectedSpeakerLabel)
+            confusions += 1;
+    }
+    const total = attributed.length;
+    const der = total > 0 ? confusions / total : 0;
+    const evaluated = total > 0;
+    const passed = evaluated && der <= maxDer;
+    return {
+        status: evaluated ? (passed ? "pass" : "fail") : "skipped",
+        total,
+        der: Number(der.toFixed(4)),
+        confusions,
+        unattributed: ran.length - attributed.length,
+        maxDer,
+        evaluated,
+        passed,
+        ...(evaluated
+            ? {}
+            : {
+                reason: ran.length > 0
+                    ? "real speaker attribution is not available on this host"
+                    : "no non-skipped turns available for diarization scoring",
+            }),
+    };
+}
+export async function runVoiceWorkbench(opts) {
+    const { scenario } = opts;
+    const startedAt = new Date().toISOString();
+    const base = {
+        schemaVersion: 1,
+        scenarioId: scenario.id,
+        classes: scenario.classes,
+        platform: opts.platform,
+        ttsRoute: opts.ttsRoute,
+        startedAt,
+    };
+    // If ASR genuinely cannot run on this host, every turn is `skipped` — the
+    // whole scenario reports `skipped`, never a false `pass`.
+    if (!(await isLocalInferenceAsrReady({ signal: opts.signal }))) {
+        const turns = scenario.turns.map((t, i) => ({
+            index: i,
+            speaker: t.speaker,
+            expectedSpeakerLabel: turnSpeakerLabel(t),
+            predictedSpeakerLabel: null,
+            status: "skipped",
+            responded: false,
+            expectRespond: t.expectRespond,
+            transcript: "",
+            expectedTranscript: turnReference(t),
+            reply: "",
+            durationMs: 0,
+            detail: { reason: "local-inference ASR not ready on this host" },
+        }));
+        return {
+            ...base,
+            overall: "skipped",
+            finishedAt: new Date().toISOString(),
+            turns,
+            diarization: scoreWorkbenchDiarization(turns),
+        };
+    }
+    const { conversation } = await opts.client.createConversation(`voice-workbench:${scenario.id}`);
+    const turns = [];
+    for (let i = 0; i < scenario.turns.length; i += 1) {
+        if (opts.signal?.aborted)
+            break;
+        turns.push(await runTurn(opts, scenario.turns[i], i, conversation.id));
+    }
+    const diarization = scoreWorkbenchDiarization(turns);
+    const hasFail = turns.some((t) => t.status === "fail");
+    const allSkipped = turns.length > 0 && turns.every((t) => t.status === "skipped");
+    const requiresDiarization = scenario.classes.includes("diarization");
+    let overall = "pass";
+    if (hasFail || diarization.status === "fail") {
+        overall = "fail";
+    }
+    else if (allSkipped ||
+        (requiresDiarization && diarization.status === "skipped")) {
+        overall = "skipped";
+    }
+    return {
+        ...base,
+        overall,
+        finishedAt: new Date().toISOString(),
+        turns,
+        diarization,
+    };
+}

package/voice/voice-turn-signal.d.ts

@@ -1,27 +1,16 @@
-import { type ShouldRespondContext } from "./should-respond";
-/** Mirrors the server-side VoiceTurnSignalMetadata shape the gate parses. */
-export interface VoiceTurnSignal {
-    endOfTurnProbability: number;
-    nextSpeaker: "agent" | "user" | "unknown";
-    agentShouldSpeak: boolean;
-    source: string;
-}
-/** Live speaker attribution from diarization (only where audio frames exist). */
-export interface VoiceTurnSpeakerAttribution {
-    /** Enrolled entity this turn was attributed to, or null when unknown. */
-    entityId: string | null;
-    /** Match confidence 0..1 (cosine-rescaled by the attribution pipeline). */
-    confidence: number;
-    /** True when attributed to the device owner / primary enrolled speaker. */
-    isOwner?: boolean;
-}
-export interface BuildVoiceTurnSignalContext extends ShouldRespondContext {
-    /** Speaker attribution for this turn (diarization; desktop/server only). */
-    speaker?: VoiceTurnSpeakerAttribution;
-    /** True when a wake word ("hey eliza") fired within the recent listen window. */
-    wakeWordActive?: boolean;
-    /** Entity ids the agent answers to without a wake word (owner + enrolled). */
-    knownSpeakerEntityIds?: readonly string[];
-}
-export declare function buildVoiceTurnSignal(transcript: string, context?: BuildVoiceTurnSignalContext): VoiceTurnSignal;
+/**
+ * Builds the `voiceTurnSignal` that the always-on (ambient) voice path attaches
+ * to a VOICE_DM turn. The server gate `core.voice_turn_signal`
+ * (packages/core/src/services/message.ts) reads this signal and SUPPRESSES the
+ * agent reply when `agentShouldSpeak === false`, `nextSpeaker === "user"`, or
+ * `endOfTurnProbability < 0.4`.
+ *
+ * The implementation is the canonical, pure definition in
+ * `@elizaos/shared/voice/respond-gate` — shared with the UI shell capture loop,
+ * the chat-view voice path, and the Voice Workbench headless runner (#8785) so
+ * the gate never drifts between what we test and what we ship. This module
+ * re-exports it to keep the `@elizaos/ui` `voice/voice-turn-signal` import path
+ * (and its tests) stable.
+ */
+export { AGENT_SELF_VOICE_THRESHOLD, type BuildVoiceTurnSignalContext, BYSTANDER_SUPPRESS_CONFIDENCE, buildVoiceTurnSignal, SERVER_EOT_SUPPRESS_THRESHOLD, type VoiceTurnSignal, type VoiceTurnSpeakerAttribution, } from "@elizaos/shared/voice/respond-gate";
 //# sourceMappingURL=voice-turn-signal.d.ts.map

package/voice/voice-turn-signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"voice-turn-signal.d.ts","sourceRoot":"","sources":["../../../../../src/voice/voice-turn-signal.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,kBAAkB,CAAC;AAE1B,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IAC1C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iFAAiF;AACjF,MAAM,WAAW,2BAA2B;IAC1C,yEAAyE;IACzE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,4EAA4E;IAC5E,OAAO,CAAC,EAAE,2BAA2B,CAAC;IACtC,iFAAiF;IACjF,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAOD,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,2BAAgC,GACxC,eAAe,CAyCjB"}
+{"version":3,"file":"voice-turn-signal.d.ts","sourceRoot":"","sources":["../../../../../src/voice/voice-turn-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,0BAA0B,EAC1B,KAAK,2BAA2B,EAChC,6BAA6B,EAC7B,oBAAoB,EACpB,6BAA6B,EAC7B,KAAK,eAAe,EACpB,KAAK,2BAA2B,GACjC,MAAM,oCAAoC,CAAC"}

package/voice/voice-turn-signal.js

@@ -5,55 +5,11 @@
  * agent reply when `agentShouldSpeak === false`, `nextSpeaker === "user"`, or
  * `endOfTurnProbability < 0.4`.
  *
- * This is the single producer for that signal, shared by the shell capture loop
- * (transcript-only — the Android/web path) and the chat-view voice path (which
- * additionally forwards a richer signal when the native VAD/turn engine supplies
- * one). It composes the transcript-level signals (semantic end-of-turn + the
- * echo/disfluency gate) with two optional audio-frame signals — speaker
- * identity and wake word — that are only present on platforms where raw PCM is
- * available (desktop/server diarization). On a transcript-only platform the
- * audio-frame inputs are simply absent and the signal degrades to the
- * transcript gate, which is the correct conservative behavior.
+ * The implementation is the canonical, pure definition in
+ * `@elizaos/shared/voice/respond-gate` — shared with the UI shell capture loop,
+ * the chat-view voice path, and the Voice Workbench headless runner (#8785) so
+ * the gate never drifts between what we test and what we ship. This module
+ * re-exports it to keep the `@elizaos/ui` `voice/voice-turn-signal` import path
+ * (and its tests) stable.
  */
-import { scoreEndOfTurn } from "./end-of-turn.js";
-import { shouldRespondToVoiceTurn, } from "./should-respond.js";
-/** Server SUPPRESS threshold for EOT — below this reads as "user still talking". */
-const SERVER_EOT_SUPPRESS_THRESHOLD = 0.4;
-/** Only a CONFIDENT bystander attribution is allowed to silence a turn. */
-const BYSTANDER_SUPPRESS_CONFIDENCE = 0.7;
-export function buildVoiceTurnSignal(transcript, context = {}) {
-    const endOfTurnProbability = scoreEndOfTurn(transcript);
-    // Transcript-level gate: the agent's own TTS echoed back through the mic, or
-    // pure thinking-noise ("um", "uh").
-    let agentShouldSpeak = shouldRespondToVoiceTurn(transcript, context);
-    // Audio-frame gate (only when diarization attributed the turn): a CONFIDENT
-    // bystander — someone who is neither the owner nor an enrolled speaker — who
-    // did NOT say the wake word is cross-talk, not a turn addressed to the agent.
-    // An uncertain attribution must never silence a real turn (fail open).
-    const speaker = context.speaker;
-    if (agentShouldSpeak && speaker && context.wakeWordActive !== true) {
-        const known = new Set(context.knownSpeakerEntityIds ?? []);
-        const enrolled = speaker.isOwner === true ||
-            (speaker.entityId !== null && known.has(speaker.entityId));
-        const confidentBystander = !enrolled &&
-            speaker.entityId !== null &&
-            speaker.confidence >= BYSTANDER_SUPPRESS_CONFIDENCE;
-        if (confidentBystander)
-            agentShouldSpeak = false;
-    }
-    // The wake word is an explicit address: it overrides bystander doubt and a
-    // soft echo/disfluency miss, because the user deliberately summoned the agent.
-    if (context.wakeWordActive === true)
-        agentShouldSpeak = true;
-    const nextSpeaker = !agentShouldSpeak
-        ? "user"
-        : endOfTurnProbability < SERVER_EOT_SUPPRESS_THRESHOLD
-            ? "user"
-            : "agent";
-    const source = context.wakeWordActive
-        ? "client-ambient+wakeword"
-        : speaker
-            ? "client-ambient+diarization"
-            : "client-ambient";
-    return { endOfTurnProbability, nextSpeaker, agentShouldSpeak, source };
-}
+export { AGENT_SELF_VOICE_THRESHOLD, BYSTANDER_SUPPRESS_CONFIDENCE, buildVoiceTurnSignal, SERVER_EOT_SUPPRESS_THRESHOLD, } from "@elizaos/shared/voice/respond-gate";

package/widgets/WidgetHost.d.ts

@@ -3,14 +3,14 @@
  *
  * Drop this into any page view:
  *   <WidgetHost slot="chat-sidebar" />
- *   <WidgetHost slot="wallet" />
+ *   <WidgetHost slot="home" layout="grid" />
  *
  * Queries the widget registry for matching declarations, wraps each in an
  * error boundary, and renders either the bundled React component or falls back
  * to the declarative UiRenderer for uiSpec widgets.
  */
-import type { ActivityEvent } from "../hooks/useActivityEvents";
-import type { PluginWidgetDeclaration, WidgetSlot } from "./types";
+import type { ActivityEvent } from "../hooks/useActivityEvents.js";
+import type { PluginWidgetDeclaration, WidgetSlot } from "./types.js";
 export interface WidgetUiActionEventDetail {
     pluginId: string;
     widgetId: string;
@@ -27,6 +27,12 @@ export interface WidgetHostProps {
     clearEvents?: () => void;
     /** Additional CSS class on the host container. */
     className?: string;
+    /**
+     * Container layout. "stack" (default) is a vertical column (the chat rail);
+     * "grid" is a responsive 1→2 column grid for surfaces that show several
+     * widgets side by side (the frontpage home). (#9143)
+     */
+    layout?: "stack" | "grid";
     /** When true, render nothing if no widgets resolve (default: true). */
     hideWhenEmpty?: boolean;
     /**
@@ -35,5 +41,5 @@ export interface WidgetHostProps {
      */
     filter?: (declaration: PluginWidgetDeclaration) => boolean;
 }
-export declare function WidgetHost({ slot, events, clearEvents, className, hideWhenEmpty, filter, }: WidgetHostProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function WidgetHost({ slot, events, clearEvents, className, layout, hideWhenEmpty, filter, }: WidgetHostProps): import("react/jsx-runtime").JSX.Element | null;
 //# sourceMappingURL=WidgetHost.d.ts.map

package/widgets/WidgetHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WidgetHost.d.ts","sourceRoot":"","sources":["../../../../../src/widgets/WidgetHost.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAIhE,OAAO,KAAK,EAAE,uBAAuB,EAAe,UAAU,EAAE,MAAM,SAAS,CAAC;AAGhF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AA4DD,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,IAAI,EAAE,UAAU,CAAC;IACjB,qEAAqE;IACrE,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACzB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,uBAAuB,KAAK,OAAO,CAAC;CAC5D;AAED,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,MAAM,EACN,WAAW,EACX,SAAS,EACT,aAAoB,EACpB,MAAM,GACP,EAAE,eAAe,kDA+DjB"}
+{"version":3,"file":"WidgetHost.d.ts","sourceRoot":"","sources":["../../../../../src/widgets/WidgetHost.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAYH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAchE,OAAO,KAAK,EAAE,uBAAuB,EAAe,UAAU,EAAE,MAAM,SAAS,CAAC;AAGhF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AA8ED,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,IAAI,EAAE,UAAU,CAAC;IACjB,qEAAqE;IACrE,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACzB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,uEAAuE;IACvE,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,uBAAuB,KAAK,OAAO,CAAC;CAC5D;AAED,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,MAAM,EACN,WAAW,EACX,SAAS,EACT,MAAgB,EAChB,aAAoB,EACpB,MAAM,GACP,EAAE,eAAe,kDA2LjB"}