@assistant-ui/core 0.1.5 → 0.1.8

package/src/index.ts

@@ -1,7 +1,267 @@
 // @assistant-ui/core - Framework-agnostic core runtime (public API)
 
-export * from "./types";
-export * from "./model-context";
-export * from "./adapters";
-export * from "./runtime";
-export * from "./runtimes";
+// === types ===
+
+export type {
+  // Message parts
+  TextMessagePart,
+  ReasoningMessagePart,
+  SourceMessagePart,
+  ImageMessagePart,
+  FileMessagePart,
+  DataMessagePart,
+  Unstable_AudioMessagePart,
+  ToolCallMessagePart,
+  ThreadUserMessagePart,
+  ThreadAssistantMessagePart,
+  // Message status
+  MessagePartStatus,
+  ToolCallMessagePartStatus,
+  MessageStatus,
+  // Thread messages
+  MessageTiming,
+  ThreadStep,
+  ThreadSystemMessage,
+  ThreadUserMessage,
+  ThreadAssistantMessage,
+  ThreadMessage,
+  MessageRole,
+  // Config
+  RunConfig,
+  AppendMessage,
+} from "./types/message";
+
+export type {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+  AttachmentStatus,
+  CreateAttachment,
+} from "./types/attachment";
+
+export type { Unsubscribe } from "./types/unsubscribe";
+
+export type { QuoteInfo } from "./types/quote";
+
+export type {
+  Unstable_MentionItem,
+  Unstable_MentionCategory,
+  Unstable_DirectiveSegment,
+  Unstable_DirectiveFormatter,
+} from "./types/mention";
+
+// === model-context ===
+
+export type {
+  // Language model settings
+  LanguageModelV1CallSettings,
+  LanguageModelConfig,
+  // Model context
+  ModelContext,
+  ModelContextProvider,
+  // Tool & instruction config
+  AssistantToolProps,
+  AssistantInstructionsConfig,
+} from "./model-context/types";
+export { mergeModelContexts } from "./model-context/types";
+
+export { tool } from "./model-context/tool";
+
+export { ModelContextRegistry } from "./model-context/registry";
+export type {
+  ModelContextRegistryToolHandle,
+  ModelContextRegistryInstructionHandle,
+  ModelContextRegistryProviderHandle,
+} from "./model-context/registry-handles";
+
+export { AssistantFrameHost } from "./model-context/frame/host";
+export { AssistantFrameProvider } from "./model-context/frame/provider";
+export type {
+  SerializedTool,
+  SerializedModelContext,
+  FrameMessageType,
+  FrameMessage,
+} from "./model-context/frame/types";
+export { FRAME_MESSAGE_CHANNEL } from "./model-context/frame/types";
+
+// === adapters ===
+
+// Attachment adapters
+export type { AttachmentAdapter } from "./adapters/attachment";
+export {
+  SimpleImageAttachmentAdapter,
+  SimpleTextAttachmentAdapter,
+  CompositeAttachmentAdapter,
+} from "./adapters/attachment";
+
+// Speech adapters
+export type {
+  SpeechSynthesisAdapter,
+  DictationAdapter,
+} from "./adapters/speech";
+export {
+  WebSpeechSynthesisAdapter,
+  WebSpeechDictationAdapter,
+} from "./adapters/speech";
+
+// Feedback adapter
+export type { FeedbackAdapter } from "./adapters/feedback";
+
+// Suggestion adapter
+export type { SuggestionAdapter } from "./adapters/suggestion";
+
+// Mention adapter
+export type { Unstable_MentionAdapter } from "./adapters/mention";
+export { unstable_defaultDirectiveFormatter } from "./adapters/mention";
+
+// Thread history adapters
+export type {
+  ThreadHistoryAdapter,
+  GenericThreadHistoryAdapter,
+  MessageFormatAdapter,
+  MessageFormatItem,
+  MessageFormatRepository,
+  MessageStorageEntry,
+} from "./adapters/thread-history";
+
+// === runtime ===
+
+// Path Types
+export type {
+  ThreadListItemRuntimePath,
+  ThreadRuntimePath,
+  MessageRuntimePath,
+  MessagePartRuntimePath,
+  AttachmentRuntimePath,
+  ComposerRuntimePath,
+} from "./runtime/api/paths";
+
+// Runtime Core Interface Types
+export type {
+  ComposerRuntimeCore,
+  ComposerRuntimeEventType,
+  DictationState,
+  ThreadComposerRuntimeCore,
+} from "./runtime/interfaces/composer-runtime-core";
+
+export type {
+  RuntimeCapabilities,
+  AddToolResultOptions,
+  ResumeToolCallOptions,
+  SubmitFeedbackOptions,
+  ThreadSuggestion,
+  SpeechState,
+  SubmittedFeedback,
+  ThreadRuntimeEventType,
+  StartRunConfig,
+  ResumeRunConfig,
+  ThreadRuntimeCore,
+} from "./runtime/interfaces/thread-runtime-core";
+
+export type {
+  ThreadListItemStatus,
+  ThreadListItemCoreState,
+  ThreadListRuntimeCore,
+} from "./runtime/interfaces/thread-list-runtime-core";
+
+export type { AssistantRuntimeCore } from "./runtime/interfaces/assistant-runtime-core";
+
+// Public Runtime Types
+export type { AssistantRuntime } from "./runtime/api/assistant-runtime";
+
+export type {
+  CreateStartRunConfig,
+  CreateResumeRunConfig,
+  CreateAppendMessage,
+  ThreadState,
+  ThreadRuntime,
+} from "./runtime/api/thread-runtime";
+
+export type {
+  ThreadListState,
+  ThreadListRuntime,
+} from "./runtime/api/thread-list-runtime";
+
+export type {
+  ThreadListItemEventType,
+  ThreadListItemRuntime,
+} from "./runtime/api/thread-list-item-runtime";
+
+export type { ThreadListItemState } from "./runtime/api/bindings";
+
+export type {
+  MessageState,
+  MessageRuntime,
+} from "./runtime/api/message-runtime";
+export type {
+  MessagePartState,
+  MessagePartRuntime,
+} from "./runtime/api/message-part-runtime";
+
+export type {
+  ThreadComposerState,
+  EditComposerState,
+  ComposerState,
+  ComposerRuntime,
+  ThreadComposerRuntime,
+  EditComposerRuntime,
+} from "./runtime/api/composer-runtime";
+
+export type {
+  AttachmentState,
+  AttachmentRuntime,
+} from "./runtime/api/attachment-runtime";
+
+// ChatModel Types
+export type {
+  ChatModelRunUpdate,
+  ChatModelRunResult,
+  CoreChatModelRunResult,
+  ChatModelRunOptions,
+  ChatModelAdapter,
+} from "./runtime/utils/chat-model-adapter";
+
+// ThreadMessageLike
+export type { ThreadMessageLike } from "./runtime/utils/thread-message-like";
+
+// External Store Message Utilities
+export {
+  getExternalStoreMessage,
+  getExternalStoreMessages,
+  bindExternalStoreMessage,
+} from "./runtime/utils/external-store-message";
+
+// ExportedMessageRepository
+export type { ExportedMessageRepositoryItem } from "./runtime/utils/message-repository";
+export { ExportedMessageRepository } from "./runtime/utils/message-repository";
+
+// === runtimes ===
+
+// Local Runtime Options
+export type { LocalRuntimeOptionsBase } from "./runtimes/local/local-runtime-options";
+
+// External Store Adapter Types (user-facing)
+export type {
+  ExternalStoreAdapter,
+  ExternalStoreMessageConverter,
+  ExternalStoreThreadListAdapter,
+  ExternalStoreThreadData,
+} from "./runtimes/external-store/external-store-adapter";
+
+// Remote Thread List (user-facing)
+export type {
+  RemoteThreadListAdapter,
+  RemoteThreadListOptions,
+  RemoteThreadInitializeResponse,
+  RemoteThreadMetadata,
+  RemoteThreadListResponse,
+} from "./runtimes/remote-thread-list/types";
+
+export { InMemoryThreadListAdapter } from "./runtimes/remote-thread-list/adapter/in-memory";
+
+// Assistant Transport Utilities
+export {
+  toAISDKTools,
+  getEnabledTools,
+  createRequestHeaders,
+} from "./runtimes/assistant-transport/utils";

package/src/internal.ts

@@ -1,7 +1,42 @@
 // @assistant-ui/core/internal - Internal implementation details
 // Not part of the public API. Used by @assistant-ui/react and other framework bindings.
 
-export * from "./subscribable";
-export * from "./utils";
+export {
+  // Sentinel
+  SKIP_UPDATE,
+  // Base classes
+  BaseSubscribable,
+  BaseSubject,
+  // Subject implementations
+  ShallowMemoizeSubject,
+  LazyMemoizeSubject,
+  NestedSubscriptionSubject,
+  EventSubscriptionSubject,
+} from "./subscribable/subscribable";
+
+export type {
+  SKIP_UPDATE as SKIP_UPDATE_TYPE,
+  // Core types
+  Subscribable,
+  SubscribableWithState,
+  NestedSubscribable,
+  EventSubscribable,
+} from "./subscribable/subscribable";
+
+// ID generation
+export {
+  generateId,
+  generateOptimisticId,
+  isOptimisticId,
+  generateErrorMessageId,
+  isErrorMessageId,
+} from "./utils/id";
+
+// Message utilities
+export { getThreadMessageText } from "./utils/text";
+
+// Composite context provider
+export { CompositeContextProvider } from "./utils/composite-context-provider";
+
 export * from "./runtime/internal";
 export * from "./runtimes/internal";

package/src/model-context/frame/host.ts

@@ -1,5 +1,5 @@
 import { ModelContextProvider, ModelContext } from "../types";
-import type { Unsubscribe } from "../../types";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import { Tool } from "assistant-stream";
 import {
   FrameMessage,

package/src/model-context/frame/provider.ts

@@ -1,5 +1,5 @@
 import { ModelContextProvider, ModelContext } from "../types";
-import type { Unsubscribe } from "../../types";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import { Tool, toJSONSchema } from "assistant-stream";
 import {
   FrameMessage,

package/src/model-context/registry.ts

@@ -6,7 +6,7 @@ import {
   AssistantToolProps,
   AssistantInstructionsConfig,
 } from "./types";
-import type { Unsubscribe } from "../types";
+import type { Unsubscribe } from "../types/unsubscribe";
 import {
   ModelContextRegistryToolHandle,
   ModelContextRegistryInstructionHandle,

package/src/model-context/types.ts

@@ -1,4 +1,4 @@
-import type { Unsubscribe } from "../types";
+import type { Unsubscribe } from "../types/unsubscribe";
 import { Tool } from "assistant-stream";
 
 // =============================================================================

package/src/react/AssistantRuntimeProvider.tsx

@@ -1,19 +1,8 @@
 import { type ReactNode, memo } from "react";
-import { useAui, type AssistantClient } from "@assistant-ui/store";
+import { type AssistantClient } from "@assistant-ui/store";
 import type { AssistantRuntime } from "../runtime/api/assistant-runtime";
 import { AssistantProviderBase } from "./AssistantProvider";
 
-export const useAssistantRuntime = (): AssistantRuntime => {
-  const aui = useAui();
-  const runtime = aui.threads().__internal_getAssistantRuntime?.();
-  if (!runtime) {
-    throw new Error(
-      "useAssistantRuntime must be used within an AssistantRuntimeProvider",
-    );
-  }
-  return runtime;
-};
-
 export const AssistantRuntimeProvider = memo(
   ({
     runtime,

package/src/react/RuntimeAdapter.ts

@@ -5,22 +5,21 @@ import {
   baseRuntimeAdapterTransformScopes,
 } from "../store/internal";
 import { attachTransformScopes } from "@assistant-ui/store";
-import { DataRenderers, Tools } from "./model-context";
+import { DataRenderers } from "./client/DataRenderers";
+import { Tools } from "./client/Tools";
 
 export const RuntimeAdapter = resource((runtime: AssistantRuntime) =>
   tapResource(RuntimeAdapterResource(runtime)),
 );
 
 attachTransformScopes(RuntimeAdapter, (scopes, parent) => {
-  const result = baseRuntimeAdapterTransformScopes(scopes, parent);
+  baseRuntimeAdapterTransformScopes(scopes, parent);
 
-  if (!result.tools && parent.tools.source === null) {
-    result.tools = Tools({});
+  if (!scopes.tools && parent.tools.source === null) {
+    scopes.tools = Tools({});
   }
 
-  if (!result.dataRenderers && parent.dataRenderers.source === null) {
-    result.dataRenderers = DataRenderers();
+  if (!scopes.dataRenderers && parent.dataRenderers.source === null) {
+    scopes.dataRenderers = DataRenderers();
   }
-
-  return result;
 });

package/src/react/client/DataRenderers.ts

@@ -1,7 +1,7 @@
 import { resource, tapState, tapCallback } from "@assistant-ui/tap";
 import { type ClientOutput } from "@assistant-ui/store";
-import { DataRenderersState } from "../types/scopes";
-import { DataMessagePartComponent } from "../types";
+import { DataRenderersState } from "../types/scopes/dataRenderers";
+import { DataMessagePartComponent } from "../types/MessagePartComponentTypes";
 
 export const DataRenderers = resource((): ClientOutput<"dataRenderers"> => {
   const [state, setState] = tapState<DataRenderersState>(() => ({

package/src/react/client/Tools.ts

@@ -4,10 +4,10 @@ import {
   type ClientOutput,
   attachTransformScopes,
 } from "@assistant-ui/store";
-import { ToolsState } from "../types/scopes";
+import { ToolsState } from "../types/scopes/tools";
 import type { Tool } from "assistant-stream";
 import { type Toolkit } from "../model-context/toolbox";
-import { ToolCallMessagePartComponent } from "../types";
+import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
 import { ModelContext } from "../../store";
 
 export const Tools = resource(
@@ -89,9 +89,8 @@ export const Tools = resource(
   },
 );
 
-attachTransformScopes(Tools, (scopes, parent) => ({
-  ...scopes,
-  ...(scopes.modelContext || parent.modelContext.source !== null
-    ? {}
-    : { modelContext: ModelContext() }),
-}));
+attachTransformScopes(Tools, (scopes, parent) => {
+  if (!scopes.modelContext && parent.modelContext.source === null) {
+    scopes.modelContext = ModelContext();
+  }
+});

package/src/react/index.ts

@@ -1,11 +1,123 @@
 /// <reference path="./types/store-augmentation.ts" />
 
-export * from "./model-context";
-export * from "./client";
-export * from "./types";
-export * from "./providers";
+// model-context
+export {
+  makeAssistantTool,
+  type AssistantTool,
+} from "./model-context/makeAssistantTool";
+export {
+  type AssistantToolUI,
+  makeAssistantToolUI,
+} from "./model-context/makeAssistantToolUI";
+export {
+  type AssistantDataUI,
+  makeAssistantDataUI,
+} from "./model-context/makeAssistantDataUI";
+export { useAssistantInstructions } from "./model-context/useAssistantInstructions";
+export {
+  useAssistantTool,
+  type AssistantToolProps,
+} from "./model-context/useAssistantTool";
+export {
+  useAssistantToolUI,
+  type AssistantToolUIProps,
+} from "./model-context/useAssistantToolUI";
+export {
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+} from "./model-context/useAssistantDataUI";
+export { useInlineRender } from "./model-context/useInlineRender";
+export type { Toolkit, ToolDefinition } from "./model-context/toolbox";
+
+// client
+export { Tools } from "./client/Tools";
+export { DataRenderers } from "./client/DataRenderers";
+
+// types
+export type {
+  EmptyMessagePartComponent,
+  EmptyMessagePartProps,
+  TextMessagePartComponent,
+  TextMessagePartProps,
+  ReasoningMessagePartComponent,
+  ReasoningMessagePartProps,
+  SourceMessagePartComponent,
+  SourceMessagePartProps,
+  ImageMessagePartComponent,
+  ImageMessagePartProps,
+  FileMessagePartComponent,
+  FileMessagePartProps,
+  Unstable_AudioMessagePartComponent,
+  Unstable_AudioMessagePartProps,
+  DataMessagePartComponent,
+  DataMessagePartProps,
+  ToolCallMessagePartComponent,
+  ToolCallMessagePartProps,
+  ReasoningGroupProps,
+  ReasoningGroupComponent,
+  QuoteMessagePartComponent,
+  QuoteMessagePartProps,
+} from "./types/MessagePartComponentTypes";
+export type {
+  ToolsState,
+  ToolsMethods,
+  ToolsClientSchema,
+} from "./types/scopes/tools";
+export type {
+  DataRenderersState,
+  DataRenderersMethods,
+  DataRenderersClientSchema,
+} from "./types/scopes/dataRenderers";
+
+// providers
+export {
+  MessageAttachmentByIndexProvider,
+  ComposerAttachmentByIndexProvider,
+} from "./providers/AttachmentByIndexProvider";
+export { ThreadListItemRuntimeProvider } from "./providers/ThreadListItemRuntimeProvider";
+export { MessageByIndexProvider } from "./providers/MessageByIndexProvider";
+export { PartByIndexProvider } from "./providers/PartByIndexProvider";
+export { TextMessagePartProvider } from "./providers/TextMessagePartProvider";
+export { ChainOfThoughtByIndicesProvider } from "./providers/ChainOfThoughtByIndicesProvider";
+export { ThreadListItemByIndexProvider } from "./providers/ThreadListItemByIndexProvider";
+export { ChainOfThoughtPartByIndexProvider } from "./providers/ChainOfThoughtPartByIndexProvider";
+export {
+  SuggestionByIndexProvider,
+  type SuggestionByIndexProviderProps,
+} from "./providers/SuggestionByIndexProvider";
+export {
+  QueueItemByIndexProvider,
+  type QueueItemByIndexProviderProps,
+} from "./providers/QueueItemByIndexProvider";
+export { ReadonlyThreadProvider } from "./providers/ReadonlyThreadProvider";
+
+// RuntimeAdapter
 export { RuntimeAdapter } from "./RuntimeAdapter";
-export * from "./runtimes";
+
+// runtimes
+export {
+  RuntimeAdapterProvider,
+  useRuntimeAdapters,
+  type RuntimeAdapters,
+} from "./runtimes/RuntimeAdapterProvider";
+export {
+  useToolInvocations,
+  type ToolExecutionStatus,
+  type AssistantTransportState,
+  type AddToolResultCommand,
+} from "./runtimes/useToolInvocations";
+export { useExternalStoreRuntime } from "./runtimes/useExternalStoreRuntime";
+export {
+  useExternalMessageConverter,
+  convertExternalMessages,
+} from "./runtimes/external-message-converter";
+export { createMessageConverter } from "./runtimes/createMessageConverter";
+export { RemoteThreadListHookInstanceManager } from "./runtimes/RemoteThreadListHookInstanceManager";
+export { RemoteThreadListThreadListRuntimeCore } from "./runtimes/RemoteThreadListThreadListRuntimeCore";
+export { useRemoteThreadListRuntime } from "./runtimes/useRemoteThreadListRuntime";
+export { useCloudThreadListAdapter } from "./runtimes/cloud/useCloudThreadListAdapter";
+export { useAssistantCloudThreadHistoryAdapter } from "./runtimes/cloud/AssistantCloudThreadHistoryAdapter";
+export { CloudFileAttachmentAdapter } from "./runtimes/cloud/CloudFileAttachmentAdapter";
 
 // AssistantProvider base
 export {
@@ -25,7 +137,9 @@ export {
   MessagePartComponent,
   MessagePrimitivePartByIndex,
   defaultComponents as messagePartsDefaultComponents,
+  type EnrichedPartState,
 } from "./primitives/message/MessageParts";
+export { MessagePrimitiveQuote } from "./primitives/message/MessageQuote";
 export {
   MessagePrimitiveAttachments,
   MessagePrimitiveAttachmentByIndex,
@@ -34,11 +148,16 @@ export {
   ComposerPrimitiveAttachments,
   ComposerPrimitiveAttachmentByIndex,
 } from "./primitives/composer/ComposerAttachments";
+export { ComposerPrimitiveQueue } from "./primitives/composer/ComposerQueue";
 export {
   ThreadListPrimitiveItems,
   ThreadListPrimitiveItemByIndex,
 } from "./primitives/threadList/ThreadListItems";
 export { ChainOfThoughtPrimitiveParts } from "./primitives/chainOfThought/ChainOfThoughtParts";
+export {
+  PartPrimitiveMessages,
+  PartPrimitiveMessagesImpl,
+} from "./primitives/part/PartMessages";
 export { ThreadListItemPrimitiveTitle } from "./primitives/threadListItem/ThreadListItemTitle";
 export {
   ThreadPrimitiveSuggestions,
@@ -49,18 +168,51 @@ export {
   ComposerPrimitiveIf,
   type UseComposerIfProps,
 } from "./primitives/composer/ComposerIf";
+export { getMessageQuote } from "./utils/getMessageQuote";
 
 // Primitive hooks (shared behavior logic)
-export * from "./primitive-hooks";
+export { useThreadMessages } from "./primitive-hooks/useThreadMessages";
+export { useThreadIsRunning } from "./primitive-hooks/useThreadIsRunning";
+export { useThreadIsEmpty } from "./primitive-hooks/useThreadIsEmpty";
+export { useComposerSend } from "./primitive-hooks/useComposerSend";
+export { useComposerCancel } from "./primitive-hooks/useComposerCancel";
+export { useComposerDictate } from "./primitive-hooks/useComposerDictate";
+export { useComposerAddAttachment } from "./primitive-hooks/useComposerAddAttachment";
+export { useMessageReload } from "./primitive-hooks/useMessageReload";
+export { useMessageBranching } from "./primitive-hooks/useMessageBranching";
+export {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "./primitive-hooks/useActionBarCopy";
+export { useActionBarEdit } from "./primitive-hooks/useActionBarEdit";
+export { useActionBarReload } from "./primitive-hooks/useActionBarReload";
+export {
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+} from "./primitive-hooks/useActionBarFeedback";
+export { useActionBarSpeak } from "./primitive-hooks/useActionBarSpeak";
+export { useActionBarStopSpeaking } from "./primitive-hooks/useActionBarStopSpeaking";
+export { useBranchPickerNext } from "./primitive-hooks/useBranchPickerNext";
+export { useBranchPickerPrevious } from "./primitive-hooks/useBranchPickerPrevious";
+export {
+  useSuggestionTrigger,
+  type UseSuggestionTriggerOptions,
+} from "./primitive-hooks/useSuggestionTrigger";
+export { useThreadListItemArchive } from "./primitive-hooks/useThreadListItemArchive";
+export { useThreadListItemDelete } from "./primitive-hooks/useThreadListItemDelete";
+export { useThreadListItemUnarchive } from "./primitive-hooks/useThreadListItemUnarchive";
+export { useThreadListItemTrigger } from "./primitive-hooks/useThreadListItemTrigger";
+export { useThreadListNew } from "./primitive-hooks/useThreadListNew";
+export { useEditComposerCancel } from "./primitive-hooks/useEditComposerCancel";
+export { useEditComposerSend } from "./primitive-hooks/useEditComposerSend";
+export { useMessageError } from "./primitive-hooks/useMessageError";
 
 // Shared AssistantRuntimeProvider
-export {
-  AssistantRuntimeProvider,
-  useAssistantRuntime,
-} from "./AssistantRuntimeProvider";
+export { AssistantRuntimeProvider } from "./AssistantRuntimeProvider";
 
 // Shared runtimes
 export {
   useLocalRuntime,
+  splitLocalRuntimeOptions,
   type LocalRuntimeOptions,
 } from "./runtimes/useLocalRuntime";

package/src/react/model-context/useInlineRender.ts

@@ -1,5 +1,5 @@
 import { FC, useCallback, useEffect, useState } from "react";
-import { ToolCallMessagePartProps } from "../types";
+import { ToolCallMessagePartProps } from "../types/MessagePartComponentTypes";
 import { create } from "zustand";
 
 export const useInlineRender = <TArgs, TResult>(

package/src/react/primitive-hooks/useActionBarSpeak.ts

@@ -0,0 +1,20 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarSpeak = () => {
+  const aui = useAui();
+
+  const disabled = useAuiState((s) => {
+    return !(
+      (s.message.role !== "assistant" ||
+        s.message.status?.type !== "running") &&
+      s.message.parts.some((c) => c.type === "text" && c.text.length > 0)
+    );
+  });
+
+  const speak = useCallback(async () => {
+    aui.message().speak();
+  }, [aui]);
+
+  return { speak, disabled };
+};