@dbx-tools/ui-mastra 0.3.11 → 0.3.12

package/README.md

@@ -28,8 +28,9 @@ Key features:
 - Concurrent threads: run several conversations at once, switch between them
   while each keeps streaming, and cancel any one independently (per-thread abort
   + routing, no shared client state).
-- Mid-turn steering: submit a message while a turn streams to fold it into the
-  live run (Mastra queue-message), with an immediate interrupt-and-resend option.
+- Mid-turn steering: submit a message while a turn streams to "send now" - it
+  interrupts the in-flight run and starts a fresh turn with your message
+  immediately.
 - Export menu for PDF and Markdown, resolving charts and tables so
   exported conversations remain useful offline.
 
@@ -50,8 +51,8 @@ understand Mastra-specific behavior:
 - `[chart:<id>]` and `[data:<id>]` assistant markers rendered as ECharts charts
   and sortable tables.
 - Concurrent multi-thread streaming, per-thread cancel, and mid-turn steering
-  (queue-message with interrupt fallback) - the native AppKit chat surface runs
-  one turn at a time and has no steering.
+  ("send now" interrupts the live run and restarts with your message) - the
+  native AppKit chat surface runs one turn at a time and has no steering.
 - Conversation export that resolves those embeds into Markdown or PDF.
 
 ## Add The Styles

package/package.json

@@ -26,19 +26,19 @@
     "shiki": "^3.0.0",
     "sql-formatter": "^15.6.9",
     "streamdown": "^2.5.0",
-    "@dbx-tools/shared-core": "0.3.11",
-    "@dbx-tools/shared-genie": "0.3.11",
-    "@dbx-tools/shared-mastra": "0.3.11",
-    "@dbx-tools/shared-model": "0.3.11",
-    "@dbx-tools/ui-appkit": "0.3.11",
-    "@dbx-tools/ui-branding": "0.3.11"
+    "@dbx-tools/shared-core": "0.3.12",
+    "@dbx-tools/shared-model": "0.3.12",
+    "@dbx-tools/ui-appkit": "0.3.12",
+    "@dbx-tools/shared-mastra": "0.3.12",
+    "@dbx-tools/ui-branding": "0.3.12",
+    "@dbx-tools/shared-genie": "0.3.12"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.11",
+  "version": "0.3.12",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/react/chat-view.tsx

@@ -35,7 +35,6 @@ import {
 import { error as errorUtil } from "@dbx-tools/shared-core";
 import {
   ArrowDownIcon,
-  FastForwardIcon,
   MessageSquareIcon,
   PanelLeftIcon,
   RefreshCwIcon,
@@ -101,7 +100,6 @@ export const ChatView = ({
   status,
   error,
   sendMessage,
-  onInterrupt,
   regenerate,
   onStop,
   className,
@@ -278,16 +276,6 @@ export const ChatView = ({
     });
   };
 
-  // Interrupt-submit: force an immediate course-correction (abort the current
-  // run, resend with this text) rather than queuing to the live turn.
-  const handleInterrupt = () => {
-    const text = input.trim();
-    if (!text || !onInterrupt) return;
-    onInterrupt({ text });
-    setInput("");
-    setIsAtBottom(true);
-    pinToBottom();
-  };
 
   const lastMessage = messages.at(-1);
   const lastEvents = lastMessage ? toolEventsByMessage[lastMessage.id] : undefined;
@@ -665,38 +653,17 @@ export const ChatView = ({
                 ) : (
                   <>
                     {/*
-                     * Running with typed text: offer an immediate interrupt
-                     * alongside the steer Send. Interrupt aborts the current
-                     * turn and resends now; Send folds the message into the
-                     * live turn (queue-steer).
-                     */}
-                    {isRunning && onInterrupt && input.trim() && (
-                      <Tooltip>
-                        <TooltipTrigger asChild>
-                          <InputGroupButton
-                            type="button"
-                            size="icon-sm"
-                            variant="outline"
-                            onClick={handleInterrupt}
-                            aria-label="Interrupt and send now"
-                          >
-                            <FastForwardIcon className="size-3" />
-                          </InputGroupButton>
-                        </TooltipTrigger>
-                        <TooltipContent>Interrupt &amp; send now</TooltipContent>
-                      </Tooltip>
-                    )}
-                    {/*
-                     * Idle, or running with typed text: the primary button
-                     * sends. A send mid-run steers the live turn (see the
-                     * driver's sendMessage).
+                     * The primary button sends. Submitting while a turn is
+                     * running is a "send now": it interrupts the live run and
+                     * starts a fresh turn with this message immediately (see
+                     * the driver's sendMessage). Idle, it just sends.
                      */}
                     <InputGroupButton
                       type="submit"
                       size="icon-sm"
                       variant="default"
                       disabled={!input.trim()}
-                      aria-label={isRunning ? "Steer response" : "Send message"}
+                      aria-label={isRunning ? "Send now (interrupts)" : "Send message"}
                     >
                       <SendIcon className="size-3" />
                     </InputGroupButton>

package/src/react/mastra-chat.tsx

@@ -901,52 +901,23 @@ export const useMastraChat = (
     [activeThreadId, getSession, noteThreadActivity, updateSession, writeMessages],
   );
 
+  // Send a message, steering the active thread. Submitting while a turn is
+  // already streaming is a "send now": it interrupts the live run and starts a
+  // fresh turn that includes the new message, immediately. `runStream` /
+  // `driveStream` supersede the prior run (abort + runToken bump + settle any
+  // running tool pills), so the interrupted turn stops cleanly and the new one
+  // takes over. An idle submit just starts a turn.
   const sendMessage = useCallback<ChatViewProps["sendMessage"]>(
     (message) => {
       const text = message.text ?? "";
       if (!text) return;
       const threadId = activeKey;
       const { before, next } = appendUserMessage(threadId, text);
-      // Steering: if a turn is already streaming on this thread, hand the
-      // message to the live run so the agent folds it into the current turn
-      // (no restart). If the server won't deliver it, fall back to
-      // interrupting + resending so a steer never silently drops.
-      if (isSessionRunning(before) && before.runId) {
-        const runId = before.runId;
-        const steerThreadId =
-          threadId === DEFAULT_THREAD_SESSION_KEY ? undefined : threadId;
-        void mastraClient
-          .queueMessage({ agentId, runId, threadId: steerThreadId, message: text })
-          .then((accepted) => {
-            if (accepted) {
-              logger.info("steer:queued", { runId });
-              return;
-            }
-            logger.info("steer:fallback-interrupt", { runId });
-            void runStream(threadId, getSession(threadId).messages);
-          });
-        return;
+      if (isSessionRunning(before)) {
+        logger.info("steer:interrupt", { threadId });
       }
       void runStream(threadId, next);
     },
-    [appendUserMessage, runStream, activeKey, getSession, mastraClient, agentId],
-  );
-
-  // Interrupt-and-resend: unconditionally abort any in-flight run on the
-  // active thread and start a fresh turn with `text` included immediately.
-  // The composer offers this alongside the queue-steer send so the user can
-  // force an immediate course-correction rather than waiting for the current
-  // turn to fold in a queued message. `runStream`/`driveStream` supersede the
-  // prior run (abort + runToken bump + pill cleanup).
-  const interrupt = useCallback(
-    (message: { text?: string }) => {
-      const text = message.text ?? "";
-      if (!text) return;
-      const threadId = activeKey;
-      const { next } = appendUserMessage(threadId, text);
-      logger.info("steer:interrupt", { threadId });
-      void runStream(threadId, next);
-    },
     [appendUserMessage, runStream, activeKey],
   );
 
@@ -1412,7 +1383,6 @@ export const useMastraChat = (
     status: activeSession.status,
     error: activeSession.error,
     sendMessage,
-    onInterrupt: interrupt,
     regenerate,
     onStop: stop,
     suggestions,

package/src/react/types.ts

@@ -89,16 +89,12 @@ export type ChatViewProps = {
    * a host driving `ChatView` itself supplies its own.
    */
   error?: Error | null;
-  sendMessage: (message: { text: string }) => void;
   /**
-   * Send a message that interrupts the in-flight turn immediately: abort the
-   * current run and start a fresh turn with this message. When provided and
-   * the chat is running, the composer shows a small "interrupt" action next
-   * to the queue-steer Send, so the user can force an immediate
-   * course-correction instead of folding the message into the live turn.
-   * Omit to offer only the queue-steer send while running.
+   * Send a message on the active thread. Submitting while a turn is streaming
+   * is a "send now": it interrupts the in-flight run and starts a fresh turn
+   * including this message immediately.
    */
-  onInterrupt?: (message: { text: string }) => void;
+  sendMessage: (message: { text: string }) => void;
   regenerate?: () => void;
   /**
    * Abort the in-flight response. When provided and the chat is running

package/src/support/mastra-client.ts

@@ -123,50 +123,6 @@ export class MastraPluginClient extends MastraClient {
     return asMastraStreamResponse(response);
   }
 
-  /**
-   * Steer a live run by handing it another message mid-turn ("queue"), via
-   * the agent `/queue-message` route. `behavior` controls what happens when
-   * the run is active: `deliver` (default) folds the message into the current
-   * turn so the agent picks it up without restarting; `persist` holds it for
-   * the next turn; `discard` drops it. Routed per call (own thread header, no
-   * shared client state) like {@link streamAgent}.
-   *
-   * Resolves `true` when the server accepted the message for delivery, `false`
-   * otherwise (unknown run / route unsupported / non-2xx) - never throws for a
-   * rejected steer, so the caller can fall back to interrupting + resending.
-   * Queue / signal routes are `@experimental` in Mastra.
-   */
-  async queueMessage(params: {
-    agentId: string;
-    runId: string;
-    threadId?: string;
-    message: string;
-    behavior?: "deliver" | "persist" | "discard";
-  }): Promise<boolean> {
-    const url = `${this.basePath}/agents/${encodeURIComponent(params.agentId)}/queue-message`;
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        credentials: "include",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.#routingHeaders({ threadId: params.threadId }),
-        },
-        body: JSON.stringify({
-          runId: params.runId,
-          ...(params.threadId ? { threadId: params.threadId } : {}),
-          message: params.message,
-          ifActive: { behavior: params.behavior ?? "deliver" },
-        }),
-      });
-      if (!response.ok) return false;
-      const body = (await response.json().catch(() => null)) as { accepted?: boolean } | null;
-      return body?.accepted === true;
-    } catch {
-      return false;
-    }
-  }
-
   /**
    * Resume a suspended `requireApproval` tool via `approve-tool-call`.
    * Reads SSE directly instead of `agent.approveToolCall()` so the