Tres formas de transmitir tokens de un LLM a Vue: fetch, useChat y Laravel Echo
Gentil Maliyamungu B. · 2026-11-15
El mismo agente de Laravel AI SDK transmitido a Vue de tres maneras: fetch con SSE, useChat, y una ejecución en cola por Reverb y Echo, con las contrapartidas.
Cuando una app Vue habla con un backend Laravel que llama a un modelo de lenguaje, «stream the answer» puede significar tres cosas bastante distintas:
- El navegador hace POST y lee el cuerpo de la respuesta a medida que llega (Server-Sent Events sobre
fetch).
- El navegador usa una biblioteca de chat que habla un protocolo más rico sobre el mismo tipo de flujo HTTP (
useChat de @ai-sdk/vue).
- El navegador hace POST, recibe un 202 y escucha un WebSocket mientras un worker de cola ejecuta el modelo y difunde eventos (Laravel Reverb y Echo).
El Laravel AI SDK admite las tres de serie. Puse el mismo pequeño agente de soporte (puede buscar un pedido con una herramienta LookupOrder) detrás de tres rutas, escribí un cliente Vue para cada una y ejecuté las tres contra una app Laravel local. Este artículo las compara con código que funciona y los detalles que solo aparecen cuando las ejecutas.
Probado con laravel/ai 1.4.0, Laravel 13.42, Reverb 1.13, ai 7.0.173, @ai-sdk/vue 4.0.173, @laravel/echo-vue 2.6.3 y Vue 3.5.
Las tres rutas
use App\Ai\Agents\SupportAgent;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Http\Request;
// A: the SDK's default SSE event format.
Route::post('/chat/raw', function (Request $request) {
$validated = $request->validate(['message' => ['required', 'string', 'max:2000']]);
return (new SupportAgent)->stream($validated['message']);
})->middleware('throttle:ai');
// B: the Vercel UI message stream that useChat expects.
Route::post('/chat', [ChatController::class, 'store'])->middleware('throttle:ai');
// C: run on a queue, broadcast over Reverb.
Route::post('/chat/queued', function (Request $request) {
$validated = $request->validate(['message' => ['required', 'string', 'max:2000']]);
(new SupportAgent)->broadcastOnQueue(
$validated['message'],
new PrivateChannel('App.Models.User.'.$request->user()->id),
);
return response()->noContent(202);
})->middleware(['auth', 'throttle:ai']);
El controlador de la ruta B es Vercel::chat($request) más ->stream($chat)->usingProtocol($chat->protocol()), detallado en el primer artículo de esta serie. Aquí me centro en el lado cliente de cada una.
A: fetch y el formato SSE predeterminado
Devolver ->stream() desde una ruta envía text/event-stream con un objeto JSON por cada línea data:. Para «Where is order 1002?» los tipos de evento, en orden, fueron:
stream_start, tool_call, tool_result, stream_start, text_start,
text_delta (x9), text_end, stream_end, [DONE]
Hay un stream_start por paso del modelo (la llamada a la herramienta es el paso uno, la respuesta es el paso dos) pero solo un stream_end, al final del todo. Un text_delta se ve así:
{"id":"01a1debe-...","invocation_id":"01a1debe-...","type":"text_delta","message_id":"01a1debe-...","delta":"Order ","timestamp":1794738385}
El EventSource del navegador solo hace peticiones GET, y no quieres el mensaje del usuario en una cadena de consulta. Así que lee el flujo con fetch:
// resources/js/composables/useFetchStream.js
import { ref } from 'vue';
export function useFetchStream(url) {
const text = ref('');
const tools = ref([]);
const status = ref('ready'); // ready | streaming | error
const error = ref(null);
let controller = null;
function handle(event) {
// Provider errors put the provider's error code in `type`, so detect them by shape.
if ('recoverable' in event && 'message' in event) {
throw new Error(event.message);
}
switch (event.type) {
case 'text_delta':
text.value += event.delta;
break;
case 'tool_call':
tools.value.push({ id: event.tool_id, name: event.tool_name, input: event.arguments, result: null });
break;
case 'tool_result': {
const call = tools.value.find((t) => t.id === event.tool_id);
if (call) call.result = event.successful ? event.result : `Failed: ${event.error}`;
break;
}
}
}
async function send(message) {
controller = new AbortController();
text.value = '';
tools.value = [];
error.value = null;
status.value = 'streaming';
let finished = false;
try {
const response = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Accept: 'text/event-stream',
'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.content ?? '',
},
body: JSON.stringify({ message }),
signal: controller.signal,
});
if (!response.ok) throw new Error(`Request failed with ${response.status}`);
const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
let buffer = '';
for (;;) {
const { value, done } = await reader.read();
if (done) break;
buffer += value;
// SSE frames are separated by a blank line.
let boundary;
while ((boundary = buffer.indexOf('\n\n')) !== -1) {
const frame = buffer.slice(0, boundary);
buffer = buffer.slice(boundary + 2);
for (const line of frame.split('\n')) {
if (!line.startsWith('data: ')) continue;
const data = line.slice(6);
if (data === '[DONE]') { finished = true; continue; }
handle(JSON.parse(data));
}
}
}
if (!finished) throw new Error('The stream ended before the server finished.');
status.value = 'ready';
} catch (e) {
if (e.name === 'AbortError') {
status.value = 'ready';
return;
}
error.value = e;
status.value = 'error';
}
}
const stop = () => controller?.abort();
return { text, tools, status, error, send, stop };
}
Dos cosas de ahí salieron de ejecutarlo, no de leer la documentación:
- Los errores no son
type: "error". Cuando hice fallar al proveedor a mitad del flujo, el evento fue {"type":"server_error","message":"The mock provider failed on purpose.","recoverable":false,...}. El type es el código de error propio del proveedor. La sección de broadcasting de la documentación dice lo mismo sobre los errores difundidos («the provider's own error code is available in the payload's type key»). En el flujo en bruto, detecto errores por la presencia de message y recoverable.
- Un flujo fallido no tiene
[DONE]. La conexión simplemente se cierra. Trata «the body ended without [DONE]» como un fallo, o una respuesta a medio escribir parecerá completa.
Las tramas también pueden partirse entre trozos de red, por eso el código almacena en búfer hasta ver una línea en blanco en lugar de analizar cada trozo directamente.
Sirve para: un widget pequeño, un botón puntual «summarize this», o un cliente en el que no quieres una dependencia. Tú controlas el análisis, el historial y el renderizado de herramientas.
B: useChat
useChat hace todo lo anterior por ti, frente al protocolo de mensajes UI de Vercel:
import { useChat } from '@ai-sdk/vue';
import { DefaultChatTransport } from 'ai';
const { messages, status, error, sendMessage, stop } = useChat({
transport: new DefaultChatTransport({
api: '/chat',
headers: { 'X-CSRF-TOKEN': csrfToken },
}),
});
Obtienes messages con parts tipadas (text, tool-LookupOrder con estados como input-available y output-available, reasoning, y así), una ref status (submitted, streaming, ready, error), stop(), e historial de conversación que se envía con cada petición. Los errores llegan como una parte de protocolo ({"type":"error","errorText":"..."}) y caen en error.
La verdadera ventaja aparece con las herramientas. La aprobación humana para herramientas arriesgadas está integrada en el protocolo: el servidor envía una parte tool-approval-request y el cliente responde con addToolApprovalResponse(). Con el formato SSE en bruto tendrías que diseñar todo eso tú.
La contrapartida: el protocolo lo define el Vercel AI SDK, que se mueve rápido. Entre versiones mayores la API del cliente ha cambiado (DefaultChatTransport, sendMessage, parts en lugar de content), así que fija las versiones y lee el changelog cuando actualices.
Sirve para: la mayoría de las interfaces de chat en las que controlas tanto la ruta Laravel como la app Vue.
C: ejecuciones en cola difundidas con Reverb y Echo
Las dos primeras opciones mantienen una petición HTTP abierta durante toda la ejecución, y también el worker PHP que la atiende. Si una ejecución puede tardar mucho, o quieres que continúe cuando el usuario cierra la pestaña, pon el agente en una cola. broadcastOnQueue() despacha un job, y el job difunde cada evento del flujo en el canal que le des.
En el lado de Laravel necesitas broadcasting y un worker de cola:
php artisan install:broadcasting --reverb
php artisan reverb:start
php artisan queue:work
El routes/channels.php predeterminado ya autoriza App.Models.User.{id} para el usuario correspondiente, así que difundo en ese canal privado.
Los eventos se difunden bajo su tipo, con nombres personalizados, así que los listeners de Echo necesitan un punto inicial. Con @laravel/echo-vue, useEcho se encarga de suscribirse al montar y de salir al desmontar:
// resources/js/composables/useQueuedChat.js
import { ref } from 'vue';
import { useEcho } from '@laravel/echo-vue';
export function useQueuedChat(userId) {
const text = ref('');
const status = ref('ready'); // ready | waiting | streaming | error
const error = ref(null);
const channel = `App.Models.User.${userId}`;
useEcho(channel, '.text_delta', (event) => {
status.value = 'streaming';
text.value += event.delta;
});
useEcho(channel, '.stream_end', () => {
status.value = 'ready';
});
useEcho(channel, '.error', (event) => {
error.value = new Error(event.message);
status.value = 'error';
});
useEcho(channel, '.stream_failed', (event) => {
// A provider error is followed by stream_failed; keep the more specific message.
error.value ??= new Error(event.message ?? 'The queued run failed.');
status.value = 'error';
});
async function send(message) {
text.value = '';
error.value = null;
status.value = 'waiting';
const response = await fetch('/chat/queued', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Accept: 'application/json',
'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.content ?? '',
},
body: JSON.stringify({ message }),
});
if (response.status !== 202) {
error.value = new Error(`Request failed with ${response.status}`);
status.value = 'error';
}
}
return { text, status, error, send };
}
Y configura Echo una vez, en el archivo de entrada de tu app:
import { configureEcho } from '@laravel/echo-vue';
configureEcho({ broadcaster: 'reverb' });
Con solo el nombre del broadcaster, @laravel/echo-vue 2.6 rellena la clave, el host, el puerto y el esquema a partir de las variables VITE_REVERB_* que install:broadcasting escribe en tu .env.
Las cargas útiles son los mismos objetos JSON que en la opción A, así que event.delta funciona igual. Esto es lo que vi al ejecutarlo:
- Con una llamada a una herramienta, la secuencia broadcast fue la misma que en el flujo HTTP: dos
stream_start, un tool_call, un tool_result, los eventos de texto y un stream_end.
- Cuando el proveedor falló, Echo recibió tanto
.error (con el mensaje del proveedor) como .stream_failed (con «The stream failed.»). El ??= conserva el mensaje útil.
- El canal es por usuario, no por ejecución. Si el mismo usuario inicia dos ejecuciones a la vez (dos pestañas), sus eventos se mezclan. Cada carga útil incluye un
invocation_id, así que puedes fijarte en el primero que veas después de enviar e ignorar el resto. O permitir solo una ejecución a la vez, como supone este composable.
Aquí no hay un «stop» integrado. Abortar significa cancelar un job en cola, lo cual tendrías que construir.
Sirve para: ejecuciones largas, trabajo en segundo plano que el usuario puede dejar, o agentes que ya disparas desde jobs. El coste son dos procesos más (Reverb y un worker) y más cosas que vigilar.
Comparación
| A: fetch + SSE | B: useChat | C: cola + Echo |
| Petición | POST, respuesta transmitida | POST, respuesta transmitida | POST devuelve 202, eventos por WebSocket |
| Código Laravel | ->stream() | Vercel::chat() + usingProtocol() | ->broadcastOnQueue() |
| Infra extra | ninguna | ninguna | Reverb (o Pusher/Ably) + worker de cola |
| Llamadas a herramientas en la UI | analizar tool_call / tool_result tú mismo | partes tool-* con estados | analizar los eventos broadcast tú mismo |
| Aprobación humana | construirlo tú mismo | integrado en el protocolo | los eventos existen (tool_approval_request), el cableado es tuyo |
| Stop / abort | AbortController | stop() | no hay forma integrada |
| Sobrevive al cierre de pestaña | no | no | sí, el job sigue ejecutándose |
| Señal de error | evento con message + recoverable, luego el cuerpo termina sin [DONE] | parte error, ref error | .error y luego .stream_failed |
| Dependencias del cliente | ninguna | ai, @ai-sdk/vue | laravel-echo, pusher-js, @laravel/echo-vue |
Cuál elegiría yo
- Empieza con
useChat si controlas ambos extremos. Obtienes partes de herramientas, aprobaciones y manejo del historial en unas pocas líneas de código.
- Baja a fetch + SSE para un widget pequeño que solo muestra texto, o cuando no puedes añadir los paquetes del AI SDK.
- Usa la cola y Echo cuando la ejecución debe sobrevivir a la petición, o el agente ya se dispara desde un job, un webhook o una tarea programada.
Elijas lo que elijas, comprueba el búfer en producción. Las tres dependen de que algo entre PHP y el navegador no retenga los datos: un proxy o CDN para A y B, la ruta WebSocket para C.
Cómo se probaron los ejemplos
Los tres clientes se ejecutaron contra una app Laravel 13 local con php artisan serve, reverb:start, queue:work, y un pequeño servidor compatible con OpenAI programado en lugar de un proveedor de pago. Vitest con happy-dom ejecutó los composables y los componentes:
- A: la respuesta de consulta del pedido y la llamada a la herramienta se analizaron bien, y un error forzado del proveedor produjo
status: 'error' con el mensaje del proveedor.
- B:
SupportChat.vue transmitió la respuesta (el botón Stop era visible a mitad del flujo), y un error mostró el mensaje de error.
- C:
useQueuedChat dentro de un componente montado recibió la respuesta en cola por Reverb, y luego recibió .error y .stream_failed ante un fallo forzado.
La demo de acompañamiento incluye el código de cada enfoque, con cobertura de Vitest para los tres clientes Vue.