Laravel AI SDK 1.1 and 1.2: Agent Skills, tool approval, Cohere

---
name: refund-policy
description: Use when a customer asks for a refund or disputes a charge.
---

# Refund policy

- Full refund within 30 days of purchase, no questions asked.
- After 30 days, offer store credit instead.
- Read references/EDGE-CASES.md before you answer about annual plans.

public function skills(): iterable
{
    return [
        resource_path('skills'),
        base_path('.agents/skills'), // share skills with your coding agent
        fn () => $this->user->team->skills->map(
            fn ($skill) => new Skill($skill->name, $skill->description, $skill->instructions)
        ),
    ];
}

use Laravel\Ai\Concerns\RemembersConversations;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\Conversational;
use Laravel\Ai\Contracts\HasTools;
use Laravel\Ai\Promptable;
use Laravel\Ai\Tools\FileStorage;
use Laravel\Ai\Tools\Filesystem\CopyFile;
use Laravel\Ai\Tools\Filesystem\DeleteFile;
use Laravel\Ai\Tools\Filesystem\MoveFile;
use Laravel\Ai\Tools\Filesystem\WriteFile;

class FileAssistant implements Agent, Conversational, HasTools
{
    use Promptable, RemembersConversations;

    public function instructions(): Stringable|string
    {
        return 'You manage files on the reports disk.';
    }

    public function tools(): iterable
    {
        return FileStorage::all('local')
            ->map(fn ($tool) => match (true) {
                $tool instanceof DeleteFile => $tool->requireApproval('This permanently deletes a file.'), 
                $tool instanceof WriteFile,
                $tool instanceof CopyFile,
                $tool instanceof MoveFile => $tool->requireApproval(),
                default => $tool, // ListFiles, ReadFile, FileExists... run freely
            })
            ->all();
    }
}

<?php

namespace App\Http\Controllers;

use App\Ai\Agents\FileAssistant;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
use Inertia\Response;
use Laravel\Ai\Approvals\Decision;
use Laravel\Ai\Approvals\Decisions;
use Laravel\Ai\Contracts\ConversationStore;

class FileChatController
{
    public function __construct(private ConversationStore $store) {}

    public function show(Request $request, string $conversation): Response
    {
        $this->authorizeConversation($request, $conversation);

        return Inertia::render('files/Chat', [
            'conversationId' => $conversation,
            'reply' => session('reply'),
            'approvals' => collect($this->store->pendingApprovalsFor($conversation))->toArray(),
        ]);
    }

    public function store(Request $request): RedirectResponse
    {
        $validated = $request->validate(['message' => ['required', 'string', 'max:2000']]);

        $response = (new FileAssistant)
            ->forUser($request->user())
            ->prompt($validated['message']);

        return to_route('files.chat', $response->conversationId)->with('reply', $response->text);
    }

    public function decide(Request $request, string $conversation): RedirectResponse
    {
        $this->authorizeConversation($request, $conversation);

        $validated = $request->validate([
            'decisions' => ['required', 'array'],
            'decisions.*.action' => ['required', Rule::in(['approve', 'reject'])],
            'decisions.*.result' => ['nullable', 'string', 'max:500'],
        ]);

        $decisions = Decisions::from(collect($validated['decisions'])->map(
            fn (array $decision) => $decision['action'] === 'approve'
                ? Decision::approve()
                : Decision::reject($decision['result'] ?? 'The user declined.'),
        )->all());

        $response = (new FileAssistant)
            ->continue($conversation, as: $request->user())
            ->prompt($decisions);

        return to_route('files.chat', $conversation)->with('reply', $response->text);
    }

    private function authorizeConversation(Request $request, string $conversation): void
    {
        abort_unless($this->store->conversationBelongsTo(
            $conversation,
            $request->user()->getMorphClass(),
            $request->user()->getKey(),
        ), 403);
    }
}

use App\Http\Controllers\FileChatController;

Route::middleware('auth')->group(function () {
    Route::post('/files/chat', [FileChatController::class, 'store'])->name('files.chat.store');
    Route::get('/files/chat/{conversation}', [FileChatController::class, 'show'])->name('files.chat');
    Route::post('/files/chat/{conversation}/decisions', [FileChatController::class, 'decide'])->name('files.chat.decide');
});

export type PendingApproval = {
    id: string
    tool: string
    arguments: Record<string, unknown>
    reason: string | null
}

<script setup lang="ts">
import { useForm } from '@inertiajs/vue3'
import { computed } from 'vue'
import type { PendingApproval } from '@/types/ai'

const props = defineProps<{
    conversationId: string
    approvals: PendingApproval[]
}>()

type Choice = { action: 'approve' | 'reject'; result?: string }

const form = useForm({
    decisions: {} as Record<string, Choice>,
})

// Every paused call needs a decision, or the SDK throws ApprovalMismatchException.
const ready = computed(() => props.approvals.every((approval) => form.decisions[approval.id]))

function choose(id: string, action: Choice['action']) {
    form.decisions[id] = action === 'approve' ? { action } : { action, result: 'The user declined this action.' }
}

function submit() {
    form.post(`/files/chat/${props.conversationId}/decisions`, { preserveScroll: true })
}
</script>

<template>
    <section v-if="approvals.length" class="approval" aria-live="polite">
        <h2>The assistant wants to do {{ approvals.length === 1 ? 'this' : 'these' }}:</h2>

        <article v-for="approval in approvals" :key="approval.id">
            <p>
                <code>{{ approval.tool }}</code>
                <span v-if="approval.reason"> · {{ approval.reason }}</span>
            </p>
            <pre>{{ JSON.stringify(approval.arguments, null, 2) }}</pre>

            <button type="button" :aria-pressed="form.decisions[approval.id]?.action === 'approve'" @click="choose(approval.id, 'approve')">
                Approve
            </button>
            <button type="button" :aria-pressed="form.decisions[approval.id]?.action === 'reject'" @click="choose(approval.id, 'reject')">
                Reject
            </button>
        </article>

        <button type="button" :disabled="!ready || form.processing" @click="submit">
            {{ form.processing ? 'Sending…' : 'Send decisions' }}
        </button>
    </section>
</template>

<script setup lang="ts">
import ToolApproval from '@/components/ToolApproval.vue'
import type { PendingApproval } from '@/types/ai'

defineProps<{
    conversationId: string
    reply: string | null
    approvals: PendingApproval[]
}>()
</script>

<template>
    <main>
        <p v-if="reply">{{ reply }}</p>
        <ToolApproval :conversation-id="conversationId" :approvals="approvals" />
    </main>
</template>

COHERE_API_KEY=your-key

use Laravel\Ai\Attributes\Model;
use Laravel\Ai\Attributes\Provider;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Enums\Lab;
use Laravel\Ai\Promptable;

#[Provider(Lab::Cohere)]
#[Model('command-a-03-2025')]
class TicketTriage implements Agent
{
    use Promptable;

    public function instructions(): Stringable|string
    {
        return 'Summarise the support ticket in one sentence.';
    }
}

use Laravel\Ai\Classification;
use Laravel\Ai\Classification\Boolean;
use Laravel\Ai\Files\Image;

$result = Classification::of('Inspect the product in this photo.', [
    Image::fromPath($photo),
])
    ->question('damaged', new Boolean('Does the product have visible damage?'))
    ->classify(provider: 'openai');

if ($result['damaged']->isTrue(threshold: 0.8)) {
    // route the return to a human
}