fix(ai): deliver a stream rejection as an error part

The guard appends the fallback message as another text delta, which the client cannot tell from the answer: it concatenates deltas, so the rejection lands glued to the truncated prefix already rendered.

Emit an error part instead. The UI message stream carries it on its own channel, so the client can drop what it has and show a failure. Text already sent still cannot be taken back, but the client now knows to discard it.

Author: Reversean

src/integrations/vercel-ai/index.ts

@@ -58,7 +58,10 @@ function guardedTransform<TOOLS extends ToolSet>(guard: StreamGuard, onReject: (
     let rejectReported = false;
 
     /**
-     * Forward the guard's verdict downstream, reporting a rejection at most once
+     * Forward the guard's verdict downstream, reporting a rejection at most once.
+     *
+     * A rejection travels as an error part rather than more text, so the client
+     * can tell it apart from the answer and drop what it has already rendered.
      *
      * @param verdict - what the guard allows to be sent
      * @param controller - transform stream controller
@@ -69,19 +72,28 @@ function guardedTransform<TOOLS extends ToolSet>(guard: StreamGuard, onReject: (
       controller: TransformStreamDefaultController<TextStreamPart<TOOLS>>,
       id: string | null
     ): void => {
+      if (verdict.rejected) {
+        if (!rejectReported) {
+          rejectReported = true;
+
+          controller.enqueue({
+            type: 'error',
+            error: new Error(verdict.emit),
+          } as TextStreamPart<TOOLS>);
+
+          onReject();
+        }
+
+        return;
+      }
+
       if (verdict.emit && id !== null) {
         controller.enqueue({
           type: 'text-delta',
           id,
           text: verdict.emit,
         } as TextStreamPart<TOOLS>);
       }
-
-      if (verdict.rejected && !rejectReported) {
-        rejectReported = true;
-
-        onReject();
-      }
     };
 
     return new TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>({

src/services/askAi/security/holdback.ts

@@ -54,10 +54,9 @@ export interface StreamGuard {
  * next one's id. Its tail is kept as scanning context instead, without which a
  * nonce split across two blocks would pass unseen.
  *
- * On rejection the rest of the answer is replaced by
- * {@link SUGGESTION_FALLBACK_MESSAGE}, emitted once. Text already sent cannot be
- * taken back, and the holdback cuts it at an arbitrary character, so the client
- * is left with a truncated prefix followed by the fallback.
+ * On rejection nothing more is released and {@link SUGGESTION_FALLBACK_MESSAGE}
+ * is returned once, for the transport to deliver as it sees fit. Text already
+ * sent cannot be taken back, and the holdback cuts it at an arbitrary character.
  *
  * @param nonce - per-request nonce used in the prompt markers
  * @returns {StreamGuard} guard for a single stream, not reusable

test/integrations/vercel-ai.test.ts

@@ -239,6 +239,27 @@ describe('VercelAIApi', () => {
       expect(emitted).toEqual([ 'tail' ]);
     });
 
+    it('should deliver a rejection as an error part instead of more text', async () => {
+      const guard = stubGuard([
+        {
+          emit: 'Could not generate an answer.',
+          rejected: true,
+        },
+        {
+          emit: '',
+          rejected: true,
+        },
+      ]);
+
+      const { parts } = await runTransformRaw(guard, [delta('first'), delta('second')]);
+
+      expect(parts.filter((part) => part.type === 'text-delta')).toEqual([]);
+      expect(parts.filter((part) => part.type === 'error')).toEqual([ {
+        type: 'error',
+        error: new Error('Could not generate an answer.'),
+      } ]);
+    });
+
     it('should report a rejection once even when the guard keeps reporting it', async () => {
       const onReject = jest.fn();
       const guard = stubGuard([