@alexkroman1/aai-ui 17.0.0 → 18.0.0

package/dist/default-client/index.html

@@ -6,9 +6,9 @@
     <title>aai</title>
     <link rel="icon" href="./favicon.ico" />
     <style>html, body { background: #FBF8F2; margin: 0; }</style>
-    <script type="module" crossorigin src="./assets/index-gJbwWrWS.js"></script>
+    <script type="module" crossorigin src="./assets/index-tc-nAWq3.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/client-audio-constants-CP13UQZt.js">
-    <link rel="stylesheet" crossorigin href="./assets/index-18HWH46b.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-5XG8PqGw.css">
   </head>
   <body>
     <main id="app"></main>

package/dist/define-client.js

@@ -5,7 +5,7 @@ import { SessionProvider, ThemeProvider } from "./context.js";
 import { t as ToolConfigContext } from "./tool-config-context-Es4YUzV2.js";
 import { SidebarLayout } from "./components/sidebar-layout.js";
 import { StartScreen } from "./components/start-screen.js";
-import { t as createBrowserSession } from "./session-core-DHE1bQ1J.js";
+import { t as createBrowserSession } from "./session-core-TOdm_Con.js";
 import { jsx } from "react/jsx-runtime";
 import { createElement, useEffect, useState } from "react";
 import { flushSync } from "react-dom";

package/dist/index.d.ts

@@ -90,12 +90,13 @@ export { mountClient } from "./define-client.tsx";
 export { useAgentState, useEvent, useToolCallStart, useToolResult } from "./hooks.ts";
 export { mountPage, type PageConfig, type PageHandle } from "./page.tsx";
 export { createBrowserSession } from "./session-core.ts";
-export type { AgentCustomEvent, BrowserSession, SessionSnapshot, } from "./session-core-types.ts";
+export type { AgentCustomEvent, BrowserSession, browserSessionBrand, SessionSnapshot, UserTurnControls, } from "./session-core-types.ts";
 export type { AgentState, ChatMessage, ClientTheme, SessionError, SessionErrorCode, ToolCallInfo, VoiceSessionOptions, WebSocketConstructor, } from "./types.ts";
 export { type ConversationItem, type UseConversationResult, useConversation, } from "./use-conversation.ts";
 export { type UseCopyResult, useCopy } from "./use-copy.ts";
 export { type UseDownloadUrlOptions, type UseDownloadUrlResult, useDownloadUrl, } from "./use-download-url.ts";
 export { type UseFlashResult, useFlash } from "./use-flash.ts";
+export { type UsePushToTalkOptions, type UsePushToTalkResult, usePushToTalk, } from "./use-push-to-talk.ts";
 export { useRunKey } from "./use-run-key.ts";
 export { type UseSessionControlsResult, useSessionControls } from "./use-session-controls.ts";
 export { type UseUserTranscriptResult, useUserTranscript } from "./use-user-transcript.ts";

package/dist/index.js

@@ -2,7 +2,7 @@ import { a as AGENT_STATE_LABELS, i as SessionErrorBanner, n as ConsoleShell, r
 import { n as setPageTitle } from "./_utils-DnQDM9Uy.js";
 import { n as fetchClientConfig } from "./client-config-CFhkMkmv.js";
 import { a as AutoScroll, i as useConversation, n as Markdown, r as ConversationView, t as MessageList } from "./message-list-CJX560b5.js";
-import { ThemeProvider, useSession, useSessionActions, useSessionError, useSessionSelector, useSessionStatus, useTheme } from "./context.js";
+import { ThemeProvider, useSession, useSessionActions, useSessionCore, useSessionError, useSessionSelector, useSessionStatus, useTheme } from "./context.js";
 import { a as inkTint, i as focusRingStyle, n as FOCUS_RING } from "./_colors-CpZO-88A.js";
 import { Button } from "./components/button.js";
 import { a as useFlash, i as useCopy } from "./url-chips-0n35fPJY.js";
@@ -12,7 +12,7 @@ import { n as ToolCallRow } from "./tool-call-block-4gXoL_eP.js";
 import { SidebarLayout } from "./components/sidebar-layout.js";
 import { StartScreen } from "./components/start-screen.js";
 import { a as useWorkflowProgress, c as isTerminal, o as useWorkflowApiRef, r as useWorkflowRun, s as createWorkflowApi } from "./use-workflow-run-ZqJWJn2-.js";
-import { i as urlSlot, n as storageGet, r as storageSet, t as createBrowserSession } from "./session-core-DHE1bQ1J.js";
+import { i as urlSlot, n as storageGet, r as storageSet, t as createBrowserSession } from "./session-core-TOdm_Con.js";
 import { mountClient, mountRoot, resolveContainer } from "./define-client.js";
 import { useAgentState, useEvent, useToolCallStart, useToolResult } from "./hooks.js";
 import { errorMessage } from "@alexkroman1/aai";
@@ -893,7 +893,7 @@ function SubmitButton({ children, pending = false, pendingLabel = "Working…",
 * unusual for even that component's render slot takes the hook alone.
 */
 const selectStarted = (snapshot) => snapshot.started;
-const selectRunning = (snapshot) => snapshot.running;
+const selectRunning$1 = (snapshot) => snapshot.running;
 /**
 * The state and the actions a Start / Pause–Resume / New conversation / End row
 * renders from, on two one-field subscriptions.
@@ -923,7 +923,7 @@ const selectRunning = (snapshot) => snapshot.running;
 function useSessionControls() {
 	const { start, toggle, restart, end } = useSessionActions();
 	const started = useSessionSelector(selectStarted);
-	const running = useSessionSelector(selectRunning);
+	const running = useSessionSelector(selectRunning$1);
 	return useMemo(() => ({
 		started,
 		running,
@@ -3011,6 +3011,166 @@ function useDownloadUrl(uploadId, options = {}) {
 	return state;
 }
 //#endregion
+//#region src/use-push-to-talk.ts
+/**
+* `usePushToTalk` — a hold-to-speak button, for an agent that declares
+* `turnDetection: "manual"`.
+*
+* The three session edges underneath (`session.userTurn`'s `start`, `commit`
+* and `clear`) are one line each; what a button needs on top of them is
+* where hand-written versions go wrong, and every one of the four is a turn
+* that is left OPEN — the microphone live and nothing ever answered:
+*
+* - **The pointer leaves.** A `mouseup` outside the button never reaches it.
+*   The handlers here capture the pointer on the way down, so the release
+*   arrives wherever it happens; an `onPointerCancel` (a scroll gesture, a
+*   system dialog) DISCARDS the turn rather than answering half a sentence.
+* - **The key repeats.** Holding a key fires `keydown` over and over, and each
+*   one would re-open the turn. Only the first counts.
+* - **The window loses focus mid-hold.** The `keyup` goes to another window
+*   and is never delivered, so the turn is committed on `blur` — what the
+*   caller would have done had the release been seen.
+* - **The component unmounts mid-hold.** The turn is discarded on the way out.
+*
+* And one that is a nuisance rather than a stuck turn: the hold key is ignored
+* while focus is in a text field, where Space is a character.
+*/
+const selectRunning = (snapshot) => snapshot.running;
+/** True when a key event came from somewhere typing belongs. */
+function isTypingTarget(target) {
+	if (typeof HTMLElement === "undefined" || !(target instanceof HTMLElement)) return false;
+	return target.isContentEditable || [
+		"INPUT",
+		"TEXTAREA",
+		"SELECT"
+	].includes(target.tagName);
+}
+/**
+* Hold-to-speak over the session's push-to-talk methods, with the four ways a
+* turn gets stuck open handled — see this module's doc.
+*
+* Must be used inside the provider `mountClient()` installs, against an agent
+* declaring `turnDetection: "manual"`; any other agent ignores the commands and
+* its server says so once.
+*
+* @example A hold-to-talk button
+* ```tsx
+* import { usePushToTalk } from "@alexkroman1/aai-ui";
+*
+* function TalkButton() {
+*   const { talking, buttonProps } = usePushToTalk();
+*   return (
+*     <button type="button" {...buttonProps}>
+*       {talking ? "Listening… release to send" : "Hold to talk (or hold Space)"}
+*     </button>
+*   );
+* }
+* ```
+*
+* @public
+*/
+function usePushToTalk(options = {}) {
+	const holdKey = options.holdKey ?? "Space";
+	const { userTurn } = useSessionCore();
+	const ready = useSessionSelector(selectRunning);
+	const [talking, setTalking] = useState(false);
+	const held = useRef(false);
+	const press = useCallback(() => {
+		if (held.current || !ready) return;
+		held.current = true;
+		setTalking(true);
+		userTurn.start();
+	}, [ready, userTurn]);
+	const release = useCallback(() => {
+		if (!held.current) return;
+		held.current = false;
+		setTalking(false);
+		userTurn.commit();
+	}, [userTurn]);
+	const cancel = useCallback(() => {
+		if (!held.current) return;
+		held.current = false;
+		setTalking(false);
+		userTurn.clear();
+	}, [userTurn]);
+	useEffect(() => {
+		if (!ready && held.current) {
+			held.current = false;
+			setTalking(false);
+		}
+	}, [ready]);
+	useEffect(() => {
+		if (holdKey === false || typeof window === "undefined") return;
+		const down = (event) => {
+			if (event.code !== holdKey || event.repeat || isTypingTarget(event.target)) return;
+			event.preventDefault();
+			press();
+		};
+		const up = (event) => {
+			if (event.code !== holdKey) return;
+			event.preventDefault();
+			release();
+		};
+		window.addEventListener("keydown", down);
+		window.addEventListener("keyup", up);
+		window.addEventListener("blur", release);
+		return () => {
+			window.removeEventListener("keydown", down);
+			window.removeEventListener("keyup", up);
+			window.removeEventListener("blur", release);
+		};
+	}, [
+		holdKey,
+		press,
+		release
+	]);
+	const cancelRef = useRef(cancel);
+	cancelRef.current = cancel;
+	useEffect(() => () => cancelRef.current(), []);
+	const buttonProps = useMemo(() => ({
+		onPointerDown: (event) => {
+			event.currentTarget.setPointerCapture?.(event.pointerId);
+			press();
+		},
+		onPointerUp: release,
+		onPointerCancel: cancel,
+		onKeyDown: (event) => {
+			if (event.key !== " " && event.key !== "Enter" || event.repeat) return;
+			event.preventDefault();
+			press();
+		},
+		onKeyUp: (event) => {
+			if (event.key !== " " && event.key !== "Enter") return;
+			event.preventDefault();
+			release();
+		},
+		onContextMenu: (event) => event.preventDefault(),
+		disabled: !ready,
+		"aria-pressed": talking
+	}), [
+		press,
+		release,
+		cancel,
+		ready,
+		talking
+	]);
+	return useMemo(() => ({
+		talking,
+		ready,
+		press,
+		release,
+		cancel,
+		buttonProps
+	}), [
+		talking,
+		ready,
+		press,
+		release,
+		cancel,
+		buttonProps
+	]);
+}
+//#endregion
 //#region src/use-workflow-runs.ts
 /**
 * The RUNS a workflow has had — the list a page shows beside its form.
@@ -3377,4 +3537,4 @@ function fileAt(input, field) {
 	return filesOf(input[field])[0];
 }
 //#endregion
-export { AGENT_STATE_LABELS, AudioResult, AutoScroll, BulletList, Button, ChatView, CheckboxField, ConsoleShell, Controls, ConversationView, Facts, Field, FileField, Form, Markdown, MessageList, NumberField, SelectField, SessionControls, SessionErrorBanner, SessionStateDot, SidebarLayout, StartScreen, SubmitButton, TextAreaField, TextField, ToolCallRow, UploadProgressBar, WORKFLOW_STATUS_LABELS, WorkflowFields, WorkflowPendingNote, WorkflowProgress, WorkflowRunError, WorkflowRunPanel, createBrowserSession, createWorkflowApi, fetchClientConfig, fieldKindFor, isTerminal, mountClient, mountPage, useAgentState, useConversation, useCopy, useDownloadUrl, useEvent, useFlash, useRunKey, useSession, useSessionActions, useSessionControls, useSessionError, useSessionSelector, useSessionStatus, useTheme, useToolCallStart, useToolResult, useUserTranscript, useWorkflowProgress, useWorkflowRun, useWorkflowRuns, useWorkflowStream, useWorkflowSubmit, useWorkflows };
+export { AGENT_STATE_LABELS, AudioResult, AutoScroll, BulletList, Button, ChatView, CheckboxField, ConsoleShell, Controls, ConversationView, Facts, Field, FileField, Form, Markdown, MessageList, NumberField, SelectField, SessionControls, SessionErrorBanner, SessionStateDot, SidebarLayout, StartScreen, SubmitButton, TextAreaField, TextField, ToolCallRow, UploadProgressBar, WORKFLOW_STATUS_LABELS, WorkflowFields, WorkflowPendingNote, WorkflowProgress, WorkflowRunError, WorkflowRunPanel, createBrowserSession, createWorkflowApi, fetchClientConfig, fieldKindFor, isTerminal, mountClient, mountPage, useAgentState, useConversation, useCopy, useDownloadUrl, useEvent, useFlash, usePushToTalk, useRunKey, useSession, useSessionActions, useSessionControls, useSessionError, useSessionSelector, useSessionStatus, useTheme, useToolCallStart, useToolResult, useUserTranscript, useWorkflowProgress, useWorkflowRun, useWorkflowRuns, useWorkflowStream, useWorkflowSubmit, useWorkflows };

package/dist/{session-core-DHE1bQ1J.js → session-core-TOdm_Con.js}

@@ -1,7 +1,7 @@
 import { r as loadClientConfig, t as buildAgentUrl } from "./client-config-CFhkMkmv.js";
 import { MIC_SEND_MAX_BUFFERED_BYTES } from "./types.js";
-import { SessionEventSchema, lenientParse } from "@alexkroman1/aai/protocol";
-import { errorMessage, safeJsonParse } from "@alexkroman1/aai";
+import { lenientParse } from "@alexkroman1/aai/protocol";
+import { SessionEventSchema, errorMessage, safeJsonParse } from "@alexkroman1/aai";
 import { omitUndefined } from "@alexkroman1/aai/utils";
 import { DEFAULT_MAX_HISTORY, WS_OPEN, createEpoch, toArgsRecord } from "@alexkroman1/aai/internal";
 import { and, assign, createActor, fromPromise, not, setup, stateIn } from "xstate";
@@ -1279,6 +1279,31 @@ function createSessionStateMachine() {
 	};
 }
 //#endregion
+//#region src/session-core-user-turn.ts
+/** Build the three push-to-talk edges. @internal */
+function createUserTurnActions(deps) {
+	return {
+		start() {
+			if (!deps.connected()) return;
+			const { state } = deps.snapshot();
+			if (state === "speaking" || state === "thinking") {
+				deps.bargeIn();
+				deps.updateState(deps.agentState.apply({ type: "LISTEN" }));
+			}
+			deps.sendJson({ type: "user_turn_start" });
+		},
+		commit() {
+			if (!deps.connected()) return;
+			deps.sendJson({ type: "user_turn_commit" });
+		},
+		clear() {
+			if (!deps.connected()) return;
+			deps.updateState({ userTranscript: null });
+			deps.sendJson({ type: "user_turn_clear" });
+		}
+	};
+}
+//#endregion
 //#region src/session-core.ts
 /**
 * Framework-agnostic voice session core.
@@ -1534,6 +1559,14 @@ function createBrowserSession(options) {
 		updateState(agentState.apply({ type: "LISTEN" }));
 		sendJson({ type: "cancel" });
 	}
+	const userTurn = createUserTurnActions({
+		snapshot: () => currentSnapshot,
+		connected: () => openSocket() !== null,
+		bargeIn: () => bargeIn(conn, audio),
+		agentState,
+		updateState,
+		sendJson
+	});
 	function reset() {
 		bargeIn(conn, audio);
 		if (openSocket()) {
@@ -1583,6 +1616,7 @@ function createBrowserSession(options) {
 		subscribe,
 		connect,
 		cancel,
+		userTurn: Object.freeze(userTurn),
 		resetState,
 		reset,
 		disconnect,

package/dist/session-core-types.d.ts

@@ -140,6 +140,45 @@ export type SessionSnapshot = {
      */
     readonly running: boolean;
 };
+/**
+ * The seal on a {@link BrowserSession}.
+ *
+ * TYPE-ONLY — there is no value at run time, so an object literal cannot carry
+ * the key and only `createBrowserSession` mints a session. That is what lets
+ * the handle grow a member without breaking anybody: push-to-talk added three
+ * REQUIRED methods and broke every hand-written double, which is the failure a
+ * handle a caller RECEIVES should not be able to cause.
+ *
+ * @public
+ */
+export declare const browserSessionBrand: unique symbol;
+/**
+ * Push-to-talk's three edges on a {@link BrowserSession} — `session.userTurn`.
+ *
+ * Only an agent declaring `turnDetection: "manual"` honours them; any other
+ * agent logs once and ignores them, because its transcriber already ends each
+ * turn on a pause. `usePushToTalk` is the hook a button is built on, and the
+ * way a `client.tsx` reaches these: a sub-handle rather than three methods on
+ * the session, so a feature one agent in many declares is not three members
+ * every session carries in its autocomplete.
+ *
+ * @public
+ */
+export type UserTurnControls = {
+    /**
+     * OPEN a turn — the button went down. Stops the agent if it is speaking
+     * (discarding its queued audio here at once, rather than a round trip later)
+     * and lets the microphone through to the transcriber.
+     */
+    start(): void;
+    /** CLOSE the turn and have the agent answer everything said since `start()` — the button came up. */
+    commit(): void;
+    /**
+     * Close the turn and THROW AWAY what was said in it — a cancelled press (the
+     * pointer left the button, Escape). The agent answers nothing.
+     */
+    clear(): void;
+};
 /**
  * A framework-agnostic voice session that manages WebSocket communication,
  * audio capture/playback, and agent state transitions.
@@ -147,9 +186,15 @@ export type SessionSnapshot = {
  * Uses a subscribe/getSnapshot pattern (compatible with React's
  * `useSyncExternalStore`). Implements `Disposable` for resource cleanup.
  *
+ * @sealed Only `createBrowserSession` produces one — see
+ * {@link browserSessionBrand}. A test double for a component is a real
+ * session with no socket, not an object literal.
+ *
  * @public
  */
 export type BrowserSession = {
+    /** The seal — see {@link browserSessionBrand}. */
+    readonly [browserSessionBrand]: true;
     /** Return the current immutable state snapshot. */
     getSnapshot(): SessionSnapshot;
     /** Subscribe to state changes. Returns an unsubscribe function. */
@@ -166,6 +211,8 @@ export type BrowserSession = {
     }): void;
     /** Cancel the current agent turn and discard in-flight TTS audio. */
     cancel(): void;
+    /** Push-to-talk's three edges — see {@link UserTurnControls}. */
+    readonly userTurn: UserTurnControls;
     /**
      * Clear messages, transcripts, and error state while keeping the current
      * connection (unlike `reset()`, which also reconnects).

package/dist/session-core-user-turn.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Push-to-talk's three edges on the browser session — `session.userTurn`'s
+ * `start`, `commit` and `clear` — for an agent that declares
+ * `turnDetection: "manual"`.
+ *
+ * Split out of `session-core.ts` at the source-length cap. Each is a frame to
+ * the server; what the server does with it is `aai-runtime`'s
+ * `pipeline-manual-turn.ts`. The two things done HERE rather than waiting a
+ * round trip for are the reason these are more than `sendJson` calls: a press
+ * stops the agent's queued audio at once, and a discarded turn's caption is
+ * cleared because no transcript for it will ever arrive.
+ *
+ * @module
+ */
+import type { SessionCommand } from "@alexkroman1/aai/protocol";
+import type { SessionStateMachine } from "./session-core-state.ts";
+import type { SessionSnapshot, UserTurnControls } from "./session-core-types.ts";
+/** What the three edges need from the session around them. @internal */
+export type UserTurnDeps = {
+    snapshot: () => SessionSnapshot;
+    /** A socket is open and can carry a frame. */
+    connected: () => boolean;
+    /** The local turn boundary — see `bargeIn` in `session-core-types.ts`. */
+    bargeIn: () => void;
+    agentState: SessionStateMachine;
+    updateState: (partial: Partial<SessionSnapshot>) => void;
+    sendJson: (msg: SessionCommand) => void;
+};
+/** Build the three push-to-talk edges. @internal */
+export declare function createUserTurnActions(deps: UserTurnDeps): UserTurnControls;

package/dist/session-core.js

@@ -1,2 +1,2 @@
-import { t as createBrowserSession } from "./session-core-DHE1bQ1J.js";
+import { t as createBrowserSession } from "./session-core-TOdm_Con.js";
 export { createBrowserSession };

package/dist/use-push-to-talk.d.ts

@@ -0,0 +1,105 @@
+/**
+ * `usePushToTalk` — a hold-to-speak button, for an agent that declares
+ * `turnDetection: "manual"`.
+ *
+ * The three session edges underneath (`session.userTurn`'s `start`, `commit`
+ * and `clear`) are one line each; what a button needs on top of them is
+ * where hand-written versions go wrong, and every one of the four is a turn
+ * that is left OPEN — the microphone live and nothing ever answered:
+ *
+ * - **The pointer leaves.** A `mouseup` outside the button never reaches it.
+ *   The handlers here capture the pointer on the way down, so the release
+ *   arrives wherever it happens; an `onPointerCancel` (a scroll gesture, a
+ *   system dialog) DISCARDS the turn rather than answering half a sentence.
+ * - **The key repeats.** Holding a key fires `keydown` over and over, and each
+ *   one would re-open the turn. Only the first counts.
+ * - **The window loses focus mid-hold.** The `keyup` goes to another window
+ *   and is never delivered, so the turn is committed on `blur` — what the
+ *   caller would have done had the release been seen.
+ * - **The component unmounts mid-hold.** The turn is discarded on the way out.
+ *
+ * And one that is a nuisance rather than a stuck turn: the hold key is ignored
+ * while focus is in a text field, where Space is a character.
+ */
+/** Options for {@link usePushToTalk}. */
+export type UsePushToTalkOptions = {
+    /**
+     * The keyboard key that holds the turn open, as a `KeyboardEvent.code` —
+     * `"Space"` by default, so the whole page is a walkie-talkie. `false` turns
+     * the global key off; the button itself still answers Space and Enter while
+     * it has focus.
+     */
+    holdKey?: string | false;
+};
+/**
+ * What {@link usePushToTalk} returns.
+ *
+ * @public
+ */
+export type UsePushToTalkResult = {
+    /** Whether a turn is being held open right now — the button is DOWN. */
+    talking: boolean;
+    /**
+     * Whether pressing would do anything: the call is live. False before Start
+     * and while paused, which is when a button should render disabled.
+     */
+    ready: boolean;
+    /** Open a turn. Interrupts the agent if it is speaking. Ignored while held. */
+    press: () => void;
+    /** Close the turn and have the agent answer it. Ignored unless held. */
+    release: () => void;
+    /** Close the turn and discard it — nothing is answered. Ignored unless held. */
+    cancel: () => void;
+    /**
+     * Spread onto a `<button>`: pointer capture, the keyboard pair, and
+     * `aria-pressed`. The handlers are the whole contract — style it however you
+     * like.
+     */
+    buttonProps: {
+        onPointerDown: (event: {
+            currentTarget: Element;
+            pointerId: number;
+        }) => void;
+        onPointerUp: () => void;
+        onPointerCancel: () => void;
+        onKeyDown: (event: {
+            key: string;
+            repeat: boolean;
+            preventDefault(): void;
+        }) => void;
+        onKeyUp: (event: {
+            key: string;
+            preventDefault(): void;
+        }) => void;
+        onContextMenu: (event: {
+            preventDefault(): void;
+        }) => void;
+        disabled: boolean;
+        "aria-pressed": boolean;
+    };
+};
+/**
+ * Hold-to-speak over the session's push-to-talk methods, with the four ways a
+ * turn gets stuck open handled — see this module's doc.
+ *
+ * Must be used inside the provider `mountClient()` installs, against an agent
+ * declaring `turnDetection: "manual"`; any other agent ignores the commands and
+ * its server says so once.
+ *
+ * @example A hold-to-talk button
+ * ```tsx
+ * import { usePushToTalk } from "@alexkroman1/aai-ui";
+ *
+ * function TalkButton() {
+ *   const { talking, buttonProps } = usePushToTalk();
+ *   return (
+ *     <button type="button" {...buttonProps}>
+ *       {talking ? "Listening… release to send" : "Hold to talk (or hold Space)"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function usePushToTalk(options?: UsePushToTalkOptions): UsePushToTalkResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-ui",
-  "version": "17.0.0",
+  "version": "18.0.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -46,7 +46,7 @@
     "use-stick-to-bottom": "^1.1.6",
     "use-sync-external-store": "^1.6.0",
     "xstate": "^5.32.6",
-    "@alexkroman1/aai": "17.0.0"
+    "@alexkroman1/aai": "18.0.0"
   },
   "devDependencies": {
     "@tailwindcss/vite": "^4.3.3",