Laravel AI SDK 1.2.1: Stop middleware for agent runs

<?php

namespace App\Ai\Agents;

use App\Ai\Middleware\EnforceDailyTokenBudget;
use App\Ai\Tools\SearchDocs;
use App\Models\Chat;
use Illuminate\Support\Facades\Cache;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasMiddleware;
use Laravel\Ai\Contracts\HasTools;
use Laravel\Ai\Middleware\Stop;
use Laravel\Ai\PendingStep;
use Laravel\Ai\Promptable;
use Stringable;

class ResearchAgent implements Agent, HasMiddleware, HasTools
{
    use Promptable;

    public function __construct(public Chat $chat) {}

    public function instructions(): Stringable|string
    {
        return 'Research the question with the docs tool, then answer briefly.';
    }

    public function tools(): iterable
    {
        return [new SearchDocs];
    }

    public function middleware(): array
    {
        return [
            // The user clicked "Stop" in the UI
            Stop::when(fn (PendingStep $step) => Cache::has($this->chat->stopKey())), 

            // Keep going only while this run is under 50k input tokens
            Stop::unless(fn (PendingStep $step) => $step->usage->inputTokens < 50_000), 

            new EnforceDailyTokenBudget($this->chat->user),
        ];
    }
}

public function stopKey(): string
{
    return "chat:{$this->id}:stopped";
}

<?php

namespace App\Ai\Middleware;

use App\Models\User;
use Closure;
use Illuminate\Support\Facades\Cache;
use Laravel\Ai\Gateway\StepResponse;
use Laravel\Ai\Gateway\StepResult;
use Laravel\Ai\PendingStep;

class EnforceDailyTokenBudget
{
    public function __construct(
        protected User $user,
        protected int $limit = 200_000,
    ) {}

    public function handle(PendingStep $step, Closure $next)
    {
        $key = "ai-tokens:{$this->user->id}:".today()->toDateString();

        if (Cache::get($key, 0) >= $this->limit) {
            return StepResult::stop(); 
        }

        return $next($step)->then(function (StepResponse $response) use ($key) {
            Cache::add($key, 0, now()->endOfDay());
            Cache::increment($key, $response->usage->inputTokens + $response->usage->outputTokens);
        });
    }
}

use App\Http\Controllers\ChatController;

Route::middleware('auth')->group(function () {
    Route::post('/chats/{chat}/stream', [ChatController::class, 'stream'])->name('chats.stream');
    Route::post('/chats/{chat}/stop', [ChatController::class, 'stop'])->name('chats.stop');
});

<?php

namespace App\Http\Controllers;

use App\Ai\Agents\ResearchAgent;
use App\Models\Chat;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;

class ChatController
{
    public function stream(Request $request, Chat $chat)
    {
        abort_unless($chat->user->is($request->user()), 403);

        Cache::forget($chat->stopKey()); // a fresh run starts un-stopped

        return (new ResearchAgent($chat))->stream($request->string('prompt'));
    }

    public function stop(Request $request, Chat $chat)
    {
        abort_unless($chat->user->is($request->user()), 403);

        Cache::put($chat->stopKey(), true, now()->addMinutes(10));

        return response()->noContent();
    }
}

<script setup lang="ts">
import { useHttp } from '@inertiajs/vue3'
import { ref } from 'vue'

const props = defineProps<{ chatId: number }>()

const prompt = ref('')
const answer = ref('')
const status = ref<'idle' | 'streaming' | 'stopped' | 'done'>('idle')

const stopRequest = useHttp('post', `/chats/${props.chatId}/stop`, {}) 

function xsrfToken(): string {
    const match = document.cookie.match(/(?:^|; )XSRF-TOKEN=([^;]+)/)

    return match ? decodeURIComponent(match[1]) : ''
}

async function ask() {
    answer.value = ''
    status.value = 'streaming'

    const response = await fetch(`/chats/${props.chatId}/stream`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json', 'X-XSRF-TOKEN': xsrfToken() },
        body: JSON.stringify({ prompt: prompt.value }),
    })

    const reader = response.body!.pipeThrough(new TextDecoderStream()).getReader()
    let buffer = ''

    while (true) {
        const { value, done } = await reader.read()
        if (done) break

        buffer += value
        const chunks = buffer.split('\n\n')
        buffer = chunks.pop() ?? ''

        for (const chunk of chunks) {
            const data = chunk.replace(/^data: /, '')
            if (data === '[DONE]') continue

            const event = JSON.parse(data)

            if (event.type === 'text_delta') answer.value += event.delta
            if (event.type === 'stream_end') {
                status.value = event.reason === 'cancelled' ? 'stopped' : 'done'
            }
        }
    }
}
</script>

<template>
    <form @submit.prevent="ask">
        <textarea v-model="prompt" />
        <button type="submit" :disabled="status === 'streaming'">Ask</button>
        <button
            v-if="status === 'streaming'"
            type="button"
            :disabled="stopRequest.processing"
            @click="stopRequest.submit()"
        >
            Stop
        </button>
    </form>

    <p>{{ answer }}</p>
    <p v-if="status === 'stopped'">Stopped. Here's what the agent found so far.</p>
</template>