DEV Community: Vas

AI Bills Don't Send Warnings: Budget Control in Laravel with laravel-ai-tasks

Vas — Mon, 27 Jul 2026 18:15:28 +0000

Your first AI call has no cost guardrail. It doesn't need one — it's one request, you're testing, it's fine.

Then it ships. Retries stack up, a queue worker chews through a backlog overnight, one tenant sends ten times the traffic of everyone else combined, and nobody notices until the provider's invoice arrives at the end of the month. There was no point in the request lifecycle where anything could have said "stop."

laravel-ai-tasks builds that stopping point in, as a first-class part of the dispatch flow — not a report you check after the damage is done.

Two checks, not one

Checking budget only before the call isn't enough, because you don't know the real cost of a call until the provider replies with token usage. A tenant sitting $2 under budget can dispatch a request that costs $5 — a pre-flight-only check would let it through.

So the package checks twice:

Check	When	Uses
Pre-flight	Before the provider call	Spend so far this month
Post-call	Right after the response	The real cost of this response

Both throw BudgetExceededException. Both run on every path: AI::send(), AI::stream(), and the queued job.

If the post-call check is the one that fires, the provider was already paid — the run still gets recorded as ok with its real cost, instead of being discarded. Otherwise that spend would disappear from the next month's budget math, and the tenant would look like they had room they'd already used.

Configure limits per tenant

// config/ai-tasks.php
'budgets' => [
    'default'    => ['monthly_usd' => 100.0],
    'tenant-abc' => ['monthly_usd' => 50.0],
],

No entry for a tenant → falls back to default. No default either → no limit. Budgeting is opt-in.

Tenant ID comes from TenantResolver:

class TenantResolver
{
    public function id(): string
    {
        if ($id = request()->header('X-Tenant-Id')) {
            return (string) $id;
        }

        if ($u = auth()->user()) {
            return (string) ($u->tenant_id ?? $u->company_id ?? $u->id ?? 'default');
        }

        return (string) config('ai-tasks.default_tenant', 'default');
    }
}

X-Tenant-Id header → authenticated user → config default. Got your own tenancy model? Bind your own resolver, one line in a service provider:

$this->app->singleton(
    \Fomvasss\AiTasks\Support\TenantResolver::class,
    fn () => new MyTenantResolver()
);

A realistic case: triaging support tickets

Budgets matter once there's real traffic behind them. A common one: every incoming support ticket runs through three AI calls before a human sees it — summarize, extract keywords for search, classify category. Three task classes, same shape:

class SummarizeTextTask extends AiTask
{
    public function __construct(
        private readonly string $text,
        private readonly int    $maxWords = 50,
    ) {}

    public function toPayload(): AiPayload
    {
        return new AiPayload(
            modality: 'text',
            messages: [new UserMessage($this->text)],
            systemPrompt: "Summarize in at most {$this->maxWords} words. Only the summary.",
            options: ['temperature' => 0.2],
        );
    }

    public function postprocess(AiResponse $resp): array|AiResponse
    {
        return ['ok' => $resp->ok, 'summary' => trim($resp->content ?? ''), 'usage' => $resp->usage];
    }
}

ExtractKeywordsTask and ClassifyContentTask follow the same pattern with a schema() closure for structured JSON. Real, unedited output for one actual ticket ("wireless keyboard hasn't arrived, order #48213, need it for a Friday demo…"):

Task	Result
`SummarizeTextTask`	`"Order #48213 for a wireless keyboard hasn't arrived; tracking hasn't updated. Considering a refund for a client demo."` — 100 in / 24 out tokens, cost `2.94e-5`
`ExtractKeywordsTask`	`["wireless keyboard", "order 48213", "tracking page", "support chat", "refund"]`
`ClassifyContentTask`	`{"category": "business", "confidence": 0.9}`

Three calls, one ticket, ~$0.0002 total. Trivial alone — but 10,000 tickets a month is roughly $2 just for triage, before human-facing AI replies, before retries, before a model upgrade for better accuracy. That's the slow, invisible cost a budget check exists to catch. And it's not abstract: each of those three calls is its own row in ai_runs, on the same tenant, feeding the exact spend the budget check compares against.

Check spend without writing a query

Every call is already logged in ai_runs with its cost, so this ships as a command:

php artisan ai:budget default

Real output from my dev sandbox ($1 budget set just to make the numbers non-trivial) — this includes the three ticket-triage calls above:

+---------+-------------------------+-------------+-------------+------------------+
| Tenant  | Period                  | Spent (USD) | Limit (USD) | Remaining (USD)  |
+---------+-------------------------+-------------+-------------+------------------+
| default | 2026-07-01 → 2026-07-31 | 0.006698    | 1.0000      | 0.9933           |
+---------+-------------------------+-------------+-------------+------------------+

Production numbers will look nothing like this, but the table and the check behind it are unchanged.

Options:

--month=YYYY-MM — check a past month
--from=YYYY-MM-DD --to=YYYY-MM-DD — arbitrary custom range (spend only — a custom range has no single monthly limit to compare against)

If the tenant's monthly budget is exhausted, the command exits non-zero. Drop it in a cron job and you have a budget alert without writing any alerting code.

Why this matters

Budget enforcement usually gets added after the surprising invoice, patched onto code that was never built to be stopped mid-call. Here it's structural: every dispatch mode hits the same two checks, every run is attributed to a tenant, and checking status is one command instead of a query you have to remember exists.

GitHub: fomvasss/laravel-ai-tasks
Packagist: packagist.org/packages/fomvasss/laravel-ai-tasks

Happy to answer questions in the comments. Stars and issues welcome 🙂

Stop Writing AI Spaghetti in Laravel - Use a Task Orchestration Layer

Vas — Fri, 19 Jun 2026 21:03:52 +0000

You add your first AI call. It's one line, a synchronous openai()->chat(), and it works perfectly.

Six months later you have seventeen of those scattered across the codebase, no idea which ones are slow, no retry logic, a tenant who blew through $300 in one night, and a queue that processes bulk image generation at the same priority as real-time chat responses.

Making AI work in production Laravel apps involves more than calling an API. You need queues, audit logs, cost tracking, retry logic, and tests that do not hit real providers. That is what fomvasss/laravel-ai-tasks is for.

It sits on top of laravel/ai (the official Laravel AI SDK) and adds the orchestration and observability layer you actually need in production.

What you get

Task classes with a generator command (ai:make-task)
Sync, queued, and streaming execution via the AI facade
Every run logged to ai_runs table (request, response, tokens, cost, status)
Driver routing with fallback chains
Multi-tenant budget tracking
Prompt caching support for Anthropic
Built-in dashboard at /ai-tasks
AI::fake() with assertions for testing
Events at every stage of execution
Text, image, embeddings, TTS, and transcription modalities

Requirements

PHP 8.3+
Laravel 12 or 13
laravel/ai ^0.8

Install

composer require fomvasss/laravel-ai-tasks
php artisan vendor:publish --tag=ai-tasks-config
php artisan vendor:publish --tag=ai-migrations
php artisan migrate

Define a task

class SummarizeTask extends AiTask
{
    public function __construct(private readonly string $text) {}

    public function modality(): string { return 'text'; }

    public function toPayload(): AiPayload
    {
        return new AiPayload(
            modality:     'text',
            messages:     [new UserMessage("Summarize: {$this->text}")],
            systemPrompt: 'Reply in 3 sentences max.',
            options:      ['temperature' => 0.3],
        );
    }

    public function postprocess(AiResponse $response): AiResponse|array
    {
        return $response;
    }
}

Run it

// Sync
$response = AI::send(new SummarizeTask($text));

// Queued
$runId = AI::queue(new SummarizeTask($text));

// Streaming (no timeout, good for long outputs)
AI::stream(new SummarizeTask($text), fn($chunk) => print($chunk));

// Runtime driver override
AI::send(new SummarizeTask($text), drivers: 'anthropic');

Driver routing with fallback

// config/ai-tasks.php
'routing' => [
    'summarize' => ['openai', 'anthropic'], // tries openai, falls back to anthropic
],

Cost tracking

'anthropic' => [
    'model' => 'claude-sonnet-4-6',
    'price' => ['in' => 3.00, 'out' => 15.00],
],

Query spend by tenant:

AiRun::where('tenant_id', $tenantId)->where('status', 'ok')->sum('cost');

shouldRun() guard

Prevent stale queued tasks from consuming tokens:

public function shouldRun(): bool
{
    return Product::find($this->productId)?->needs_analysis ?? false;
}

Testing without real API calls

$fake = AI::fake([
    'summarize' => 'This is a summary.',
    '*'          => 'Default fallback.',
]);

$fake->assertSent(SummarizeTask::class);
$fake->assertSentCount(1);

Supported providers

OpenAI, Anthropic, Gemini, DeepSeek, Groq, Mistral, xAI, Ollama, ElevenLabs, and any laravel/ai-compatible provider.

GitHub: https://github.com/fomvasss/laravel-ai-tasks
Packagist: https://packagist.org/packages/fomvasss/laravel-ai-tasks

Happy to answer questions in the comments. Stars and issues welcome 🙂

Support

If this package saves you time, consider supporting development (and this will help me 🥹):

☕ Ko-fi
🏦 Monobank
💚 USDT TRC20: THLgp6DxiAtbNHvgnKV56vk1L38UuUagKf

Stop Pre-Generating Image Thumbnails in Laravel — Do It On-The-Fly Instead

Vas — Thu, 07 May 2026 20:21:26 +0000

Every Laravel project eventually hits the same wall: a designer asks for a new image size, and suddenly you're writing a migration, a queue job, and a Media Library conversion — just to serve a 400px thumbnail.

There's a simpler way. Generate image variants on demand, cache the result permanently, and move on.

That's exactly what laravel-imagepresets does.

The Problem With Pre-Generated Thumbnails

When you pre-generate image variants (the approach Spatie Media Library encourages by default), you pay upfront:

Storage costs for every variant of every image, even ones never viewed
Queue processing time on upload
Pain when design requirements change and you need to regenerate thousands of files
Complex seeding/migration logic for existing images

On-the-fly processing flips this: you process an image the first time it's requested, cache the result, and never touch it again. The tradeoff is a slightly slower first request — which is usually invisible to users.

What Is laravel-imagepresets?

It's a Laravel package built on League/Glide that gives you:

A single /imagepreset route that handles all image transformations
Automatic caching to any Laravel filesystem disk (local, S3, GCS, FTP)
A clean API — helper function, Facade, and Blade directive
Named presets so you define sizes once and reuse them everywhere
Production-ready security: SSRF protection, allowlists, signed URLs, SVG sanitization

Installation

composer require fomvasss/laravel-imagepresets
php artisan vendor:publish --tag=imagepresets-config

The service provider is auto-discovered. No manual registration needed.

Your First Image URL

// Resize to 800px wide, convert to WebP
$url = imagepreset_url('storage/images/photo.jpg', ['w' => 800, 'fm' => 'webp']);
// → https://example.com/imagepreset?fm=webp&src=storage%2Fimages%2Fphoto.jpg&w=800

On the first hit, Glide resizes and converts the image, stores it on your configured disk, and returns it with a one-year Cache-Control header. The next request? Pure cache — Laravel never runs.

Named Presets: Define Once, Use Everywhere

Hardcoding ['w' => 300, 'h' => 200, 'fm' => 'webp', 'fit' => 'crop'] everywhere is a maintenance headache. Named presets solve this.

In config/imagepresets.php:

'presets' => [
    'thumb'     => ['w' => 300, 'h' => 200, 'fm' => 'webp', 'fit' => 'crop'],
    'hero'      => ['w' => 1200, 'fm' => 'webp', 'q' => 85],
    'avatar'    => ['w' => 96,  'h' => 96,  'fm' => 'webp', 'fit' => 'crop'],
    'og_banner' => ['w' => 1300, 'h' => 650, 'fit' => 'fill-max', 'fm' => 'jpg', 'bg' => 'ffffff'],
],

Then in your code:

// String shorthand
$url = imagepreset_url('photo.jpg', 'thumb');

// Facade
Imagepreset::url('photo.jpg', 'hero');

{{-- Blade directive --}}
<img src="@imagepreset('photo.jpg', 'thumb')" alt="Thumbnail">

Need to override one param? Pass it alongside the preset name:

// Use thumb preset but output JPG instead of WebP
$url = imagepreset_url('photo.jpg', ['preset' => 'thumb', 'fm' => 'jpg']);

Fit Methods Explained

The fit parameter controls how the image fills the target dimensions. Choosing the wrong one is a common source of stretched or oddly-cropped images.

Fit	Use when...
`crop`	You need exact pixel dimensions (cards, avatars). Edges may be trimmed.
`contain`	The full image must be visible. No fill — transparent space is left.
`fill`	Full image visible, remaining canvas filled with `bg` color. May upscale.
`fill-max`	Like `fill` but never upscales. Great for OG images and social banners.
`max`	Like `contain` but never upscales beyond original size.
`stretch`	Forces exact dimensions ignoring aspect ratio. Rarely a good idea.

For OG images, fill-max is your friend:

$url = imagepreset_url('post-image.jpg', [
    'w' => 1300, 'h' => 650,
    'fit' => 'fill-max',
    'fm' => 'jpg',
    'bg' => 'ffffff',
]);

S3 / Remote Disk Support

Just set the disk in your .env:

IMAGEPRESET_DISK=s3
IMAGEPRESET_PATH=imagepresets

The package detects remote disks automatically. Glide processes the image locally, uploads the result to S3 via Flysystem, deletes the local temp file, and streams the response directly from S3. No extra code needed.

Security Out of the Box

Open image-resizing endpoints are a common attack surface. The package handles the main threats:

Allowlists prevent arbitrary dimensions from being requested:

'allowed_widths'  => [100, 200, 400, 800, 1200],
'allowed_heights' => [100, 200, 400, 600],
'allowed_formats' => ['webp', 'jpg', 'png'],

SSRF protection blocks remote image sources that point to private IPs or localhost.

Image bomb protection rejects files that exceed max_image_pixels (default: 150 Mpx).

Signed URLs (optional) make it impossible to tamper with parameters:

IMAGEPRESET_SIGNED_URL=true

Once enabled, imagepreset_url() automatically generates HMAC-signed URLs. Changing any parameter returns 403.

Race Condition Protection

What happens when 50 users simultaneously request the same uncached image? Without protection, you'd process the same image 50 times.

The package uses Cache::lock() to ensure only one process generates each variant. Set CACHE_DRIVER=redis for this to work correctly across multiple servers.

Audit Log: Discover What Your Frontend Actually Needs

Before locking down allowlists in production, you can enable audit logging in development to see exactly which params your frontend requests:

IMAGEPRESET_AUDIT_LOG=true

Then extract unique values from your logs:

grep -oh '"w":[0-9]*' storage/logs/*.log | sort -u

Use the findings to populate your allowlists before deploying.

CDN and Nginx Caching

Every response ships with:

Cache-Control: public, max-age=31536000, s-maxage=31536000, immutable
ETag: "<hash>"

This makes it trivial to cache at the edge. The README includes ready-to-use configs for Nginx proxy cache and Cloudflare Cache Rules.

To verify your cache is working:

# Run twice — first should be MISS, second HIT
curl -s -o /dev/null -D - "https://example.com/imagepreset?src=photo.jpg&w=800&fm=webp"

Clearing the Cache

# Clear all cached presets
php artisan imagepresets:clear

# Clear a specific remote disk
php artisan imagepresets:clear --disk=s3 --path=imagepresets

Requirements

Dependency	Version
PHP	^8.1
Laravel	10 / 11 / 12 / 13
league/glide	^2.0 \| ^3.0

Optional: imagick extension for AVIF output and SVG rasterization.

Wrapping Up

If your project doesn't need the full power of Spatie Media Library — associations, conversions, responsive images — and you just want to serve the right image size without pre-generating everything, laravel-imagepresets is worth a look.

Install it, define a few presets, drop @imagepreset() into your Blade templates, and you're done.

composer require fomvasss/laravel-imagepresets

→ GitHub · Packagist

Have questions or found a bug? Open an issue on GitHub.