@athenaintel/react 0.57.2 → 0.60.0

package/dist/chat/AthenaChat.d.ts

@@ -1,11 +1,14 @@
 import { type StatewireDecisionConfirmer } from './StatewireApprovalCard';
 import type { ThreadDriverSurface } from '../agent-runtime/src/thread-driver';
-import { type ComposerSendOrStopProps } from '../chat-ui/thread/composer-send-or-stop';
+import { type ComposerAction } from '../chat-ui/composer/composer-action';
+import type { ComposerSlashCommand } from '../chat-ui/composer/slash-commands';
 import type { DictationEngine } from '../dictation/dictation-engine';
+import type { MentionRootCategory } from '../chat-ui/mentions/suggestions/data/use-mention-suggestions';
 import type { MentionTool } from '../chat-ui/mentions/suggestions/data/types';
 import { type WelcomeSuggestion } from './athena-chat-welcome';
 import type { EmptyMessagePartComponent, ReasoningMessagePartProps, ReasoningMessagePartComponent, TextMessagePartComponent, ToolCallMessagePartComponent } from '@assistant-ui/react';
 import { type FC, type ReactNode } from 'react';
+import { type AthenaChatTurnChanges } from './turn-changes';
 import { type AthenaChatContinueByVoice, type AthenaChatVoiceOptions } from './chat-voice-controls';
 export type { AthenaChatContinueByVoice, AthenaChatVoiceOptions } from './chat-voice-controls';
 export type { WelcomeSuggestion } from './athena-chat-welcome';
@@ -64,6 +67,20 @@ export interface AthenaChatProps {
     /** Tools / Toolkits offered by the composer's `@` menu beside the asset
      *  library. Defaults to the toolkits enabled on the provider. */
     mentionTools?: MentionTool[];
+    /**
+     * What the composer's `@` menu offers beside Tools / Toolkits (which follow `mentionTools`).
+     * Defaults to the asset library: Favorites, Assets, Projects and Folders. Add `team` for people
+     * (the workspace's members and groups; an Athena admin's people, ranked, as in Olympus), `agents`
+     * to name agents for a message, `browse_profiles` and `drives`. The menu shows them in Athena's
+     * order whatever order they are given in.
+     *
+     * With `agents`, choosing one names it for the message: a chip on the composer's To line, never
+     * text, and the send names it to Athena (`addressed_agents`, on the run and on the message), as
+     * Olympus's composer does. The person's own assistant and the agents the chat's agent picker lists
+     * are offered, to Athena admins only for now, as in Olympus; Athena checks every agent a message
+     * names. A person mention is the link Olympus writes (`mention://person?id=…&email=…&name=…`).
+     */
+    mentionCategories?: readonly AthenaChatMentionCategory[];
     /** Suggestion cards shown on the welcome screen. Pass `[]` to hide.
      *  For workflow launchers outside AthenaChat, use `useSendMessage()`.
      */
@@ -113,6 +130,34 @@ export interface AthenaChatProps {
      * no offer. A `readOnly` chat never shows it.
      */
     continueByVoice?: AthenaChatContinueByVoice | null;
+    /**
+     * The turn changes card: a finished assistant turn that changed files ends with Codex's card,
+     * "Edited N files +A −D", Undo and View changes, and the first three files with theirs ("Show N
+     * more files" for the rest). The SDK draws it and places it; the host reads each turn's changes
+     * (`read`, once per finished turn, by the runs that answered it) and does what Undo and View
+     * changes mean (`onUndo`, `onView`; `reviewScope` says whether View changes opens the chat's
+     * changes or the turn's). Off unless `enabled`: absent, `null` or off, nothing renders and
+     * nothing is read.
+     */
+    turnChanges?: AthenaChatTurnChanges | null;
+    /**
+     * Suggested follow-up prompts: once a run the person watched finishes with a reply, up to three
+     * prompts they might type next show as chips just above the composer. A chip puts its text in the
+     * composer and sends nothing; the chips go away once the person types or sends, or a new run
+     * starts. A run that was stopped, failed or waits on the person gets none, and neither does a
+     * conversation opened at rest. Athena writes them from the turn's last message and reply
+     * (`POST /api/chat/follow-up-suggestions`, with the chat's own credential, one request per
+     * finished turn, charged to the conversation); a failed request shows nothing. Defaults to
+     * `false`: off, nothing is requested.
+     */
+    followUpSuggestions?: boolean;
+}
+/** What a host's `composer.onBeforeSend` hears of the message about to go. */
+export interface AthenaChatBeforeSend {
+    /** `send` starts a turn; `queue` waits behind the run that is live. */
+    action: Extract<ComposerAction, 'send' | 'queue'>;
+    /** Its words as typed (empty for a message of attachments or a quote alone). */
+    text: string;
 }
 export interface AthenaChatComposerSlots {
     /** The empty composer's hint (default "Type @ to tag an asset"). */
@@ -129,12 +174,32 @@ export interface AthenaChatComposerSlots {
      * as given, above any voice offer, quote or attachment preview; absent, nothing changes.
      */
     aboveEditor?: ReactNode;
-    /** Toolbar contents after the attach button. */
+    /**
+     * Toolbar contents after the attach button. In a composer too narrow for every chip they wrap
+     * onto another row, so the mic, voice and Send stay in reach.
+     */
     toolbarStart?: ReactNode;
     /** Toolbar contents before the mic and the send/stop control. */
     toolbarEnd?: ReactNode;
-    /** Host work to run before a draft submits (also runs for a dictated send). */
-    onBeforeSend?: ComposerSendOrStopProps['onBeforeSend'];
+    /**
+     * The composer's own attach button (the paperclip). `false` leaves it out, for a host that offers
+     * attaching from a control of its own in a slot (`useAthenaComposerActions().openFilePicker`);
+     * pasting and dropping files still attach them. Default `true`.
+     */
+    attachButton?: boolean;
+    /**
+     * The composer's own `@` button. `false` leaves it out, for a host that opens the `@` menu from a
+     * control of its own in a slot (`useAthenaComposerActions().openMentionMenu`); typing `@` still
+     * opens it. Default `true`.
+     */
+    mentionButton?: boolean;
+    /**
+     * Host work awaited before a message goes, however it is sent: Enter, the send button, or a
+     * dictated send, once each. It hears whether the message starts a turn or queues, and its words.
+     * Not for a message the chat outbox holds while Athena can't be reached (it goes later). A
+     * rejection keeps the message in the composer, unsent.
+     */
+    onBeforeSend?: (context: AthenaChatBeforeSend) => void | Promise<void>;
     /**
      * Why the composer's controls that need Athena are off, while the host knows Athena can't be
      * reached (from its own reachability: Olympus's model, the desktop app's main process). Attach
@@ -147,6 +212,12 @@ export interface AthenaChatComposerSlots {
      * meanwhile is refused as before, by the chat outbox's own reachability. `null` or absent: on.
      */
     needsConnectionReason?: string | null;
+    /**
+     * The composer's `/` commands: typing `/` opens a menu of them, and picking
+     * one runs it (`TiptapComposer`'s `slashCommands`). Absent or empty: `/` is
+     * plain text.
+     */
+    slashCommands?: readonly ComposerSlashCommand[];
 }
 export interface AthenaChatDictationOptions {
     /**
@@ -203,6 +274,11 @@ export interface AthenaReasoningPartProps extends ReasoningMessagePartProps {
     TextComponent?: TextMessagePartComponent;
 }
 export declare const AthenaChat: FC<AthenaChatProps>;
+/**
+ * A category a host can offer in AthenaChat's `@` menu (`AthenaChatProps.mentionCategories`).
+ * Tools and Toolkits are not among them: they follow `mentionTools`.
+ */
+export type AthenaChatMentionCategory = Exclude<MentionRootCategory, 'tools' | 'toolkits'>;
 export declare const AthenaReasoningPart: FC<AthenaReasoningPartProps>;
 export declare const AthenaAssistantMessage: FC<AthenaAssistantMessageProps>;
 export declare const AthenaAssistantActionBar: FC<AthenaAssistantActionBarProps>;