@fleetbase/fleetops-engine 0.6.68 → 0.6.69

package/server/tests/Unit/Models/SmallModelSurfacesTest.php

@@ -176,45 +176,51 @@ test('customer creation forces the customer type and scopes orders', function ()
     expect($customer->orders())->toBeInstanceOf(HasMany::class);
 });
 
-test('contact observer availability checks and deletion resolve against users', function () {
+test('contact observer deletion releases the managed account and leaves team members alone', function () {
     $connection = fleetopsSmallModelBoot();
-    $connection->table('users')->insert(['uuid' => 'user-2', 'company_uuid' => 'company-1', 'email' => 'taken@example.test', 'phone' => '+6512345678']);
+    config(['activitylog.enabled' => false]);
+    app()->bind(Illuminate\Contracts\Config\Repository::class, fn () => config());
+    $connection->getSchemaBuilder()->create('drivers', function ($blueprint) {
+        $blueprint->increments('id');
+        $blueprint->string('uuid')->nullable();
+        $blueprint->string('company_uuid')->nullable();
+        $blueprint->string('user_uuid')->nullable();
+        $blueprint->timestamp('deleted_at')->nullable();
+    });
+    $connection->table('users')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'company_uuid' => 'company-1', 'type' => 'contact'],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'type' => 'user'],
+    ]);
 
-    $observer   = new ContactObserver();
-    $reflection = new ReflectionClass($observer);
+    $observer = new ContactObserver();
 
     $contact = new Fleetbase\FleetOps\Models\Contact();
-    $contact->setRawAttributes(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'user_uuid' => 'user-1', 'email' => 'taken@example.test', 'phone' => '+6512345678', 'type' => 'contact'], true);
+    $contact->setRawAttributes(['uuid' => 'contact-1', 'company_uuid' => 'company-1', 'user_uuid' => '11111111-1111-4111-8111-111111111111', 'type' => 'contact'], true);
     $contact->exists = true;
 
-    $emailCheck = $reflection->getMethod('isEmailUnavailable');
-    $emailCheck->setAccessible(true);
-    expect($emailCheck->invoke($observer, $contact))->toBeTrue();
-
-    $phoneCheck = $reflection->getMethod('isPhoneUnavailable');
-    $phoneCheck->setAccessible(true);
-    expect($phoneCheck->invoke($observer, $contact))->toBeTrue();
+    $staffContact = new Fleetbase\FleetOps\Models\Contact();
+    $staffContact->setRawAttributes(['uuid' => 'contact-2', 'company_uuid' => 'company-1', 'user_uuid' => '22222222-2222-4222-8222-222222222222', 'type' => 'contact'], true);
+    $staffContact->exists = true;
 
-    $contact->email = 'free@example.test';
-    $contact->phone = '+6599999999';
-    expect($emailCheck->invoke($observer, $contact))->toBeFalse()
-        ->and($phoneCheck->invoke($observer, $contact))->toBeFalse();
-
-    // Deletion removes the associated user account
     $observer->deleted($contact);
-    expect(true)->toBeTrue();
+    $observer->deleted($staffContact);
+
+    // The managed account had no other profile, so it is deleted
+    expect($connection->table('users')->where('uuid', '11111111-1111-4111-8111-111111111111')->value('deleted_at'))->not->toBeNull()
+        ->and($connection->table('users')->where('uuid', '22222222-2222-4222-8222-222222222222')->value('deleted_at'))->toBeNull();
 });
 
 test('contact observer rejects saves whose email or phone belongs to another account', function () {
     $connection = fleetopsSmallModelBoot();
-    $connection->table('users')->insert(['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'email' => 'taken@example.test', 'phone' => '+6512345678']);
+    $connection->table('users')->insert([
+        ['uuid' => '11111111-1111-4111-8111-111111111111', 'company_uuid' => 'company-1', 'type' => 'contact', 'email' => 'free@example.test', 'phone' => '+6599999999'],
+        ['uuid' => '22222222-2222-4222-8222-222222222222', 'company_uuid' => 'company-1', 'type' => 'user', 'email' => 'taken@example.test', 'phone' => '+6512345678'],
+    ]);
 
     $observer = new ContactObserver();
 
-    // The availability checks are private, so the guards can only be reached
-    // through saving() with a contact that genuinely collides on a real table.
     // hasUser() keys off a well-formed uuid, so a real one keeps saving() from
-    // detouring into account provisioning before it reaches the guards.
+    // detouring into account provisioning before it reaches the sync.
     $contact = new Fleetbase\FleetOps\Models\Contact();
     $contact->setRawAttributes([
         'uuid'         => 'contact-collide',
@@ -226,23 +232,16 @@ test('contact observer rejects saves whose email or phone belongs to another acc
     ], true);
     $contact->exists = true;
 
-    // wasChanged() reads the post-save change set, which setRawAttributes does
-    // not populate — syncChanges promotes the pending edit into it.
     $contact->email = 'taken@example.test';
-    $contact->syncChanges();
 
     expect(fn () => $observer->saving($contact))
-        ->toThrow(Exception::class, 'Email attempting to update for contact is not available.');
+        ->toThrow(Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException::class, 'This email is already in use by another account.');
 
-    // The phone guard sits behind the email one, so it only surfaces once the
-    // email is back to an available value
-    $contact->syncOriginal();
     $contact->email = 'free@example.test';
     $contact->phone = '+6512345678';
-    $contact->syncChanges();
 
     expect(fn () => $observer->saving($contact))
-        ->toThrow(Exception::class, 'Phone attempting to update for contact is not available.');
+        ->toThrow(Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException::class, 'This phone number is already in use by another account.');
 });
 
 test('tracking status request authorizes by session and rejects duplicates', function () {

package/server/tests/Unit/Observers/ObserverListenerSeamsTest.php

@@ -98,11 +98,16 @@ test('driver observer seams unassign orders and resolve the driver user', functi
         ->and($connection->table('orders')->where('uuid', 'order-seam-1')->value('driver_assigned_uuid'))->toBeNull()
         ->and($connection->table('orders')->where('uuid', 'order-seam-2')->value('driver_assigned_uuid'))->toBe('driver-other');
 
-    // The linked account resolves only when it is still a plain user
+    // The linked account resolves whatever its type: releaseForProfile decides
+    // whether a managed account is deleted and leaves a team member alone
     expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$driver])?->uuid)->toBe('user-seam-1');
 
+    $managedDriver = new Driver();
+    $managedDriver->setRawAttributes(['uuid' => 'driver-seam-2', 'user_uuid' => 'user-seam-2'], true);
+    expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$managedDriver])?->uuid)->toBe('user-seam-2');
+
     $driverWithoutUser = new Driver();
-    $driverWithoutUser->setRawAttributes(['uuid' => 'driver-seam-2', 'user_uuid' => 'user-seam-2'], true);
+    $driverWithoutUser->setRawAttributes(['uuid' => 'driver-seam-3', 'user_uuid' => null], true);
     expect(fleetopsObserverSeamInvoke(Fleetbase\FleetOps\Observers\DriverObserver::class, 'findDriverUser', [$driverWithoutUser]))->toBeNull();
 });
 

package/server/tests/Unit/Providers/FleetOpsAiRegistrationTest.php

@@ -4,6 +4,10 @@ if (!class_exists('Fleetbase\Ai\Support\AiCapabilityRegistry', false)) {
     eval('namespace Fleetbase\Ai\Support; class AiCapabilityRegistry { public array $registered = []; public function register($capability) { $this->registered[] = $capability; return $this; } }');
 }
 
+if (!class_exists('Fleetbase\Ai\Support\Commands\AiCommandRegistry', false)) {
+    eval('namespace Fleetbase\Ai\Support\Commands; class AiCommandRegistry { public array $registered = []; public function registerMany(array $commands) { $this->registered = array_merge($this->registered, $commands); return $this; } }');
+}
+
 if (!class_exists('Fleetbase\Ai\Support\AiQueryRegistry', false)) {
     eval('namespace Fleetbase\Ai\Support; class AiQueryRegistry { public array $registered = []; public function register($resource = null) { $this->registered[] = $resource; return $this; } }');
 }
@@ -44,9 +48,18 @@ test('ai capability registration wires query resources and capabilities', functi
     $capabilityRegistry = app(Fleetbase\Ai\Support\AiCapabilityRegistry::class);
 
     fwrite(STDERR, "\nDBG ai: " . json_encode([is_object($queryRegistry) ? get_class($queryRegistry) : gettype($queryRegistry), is_object($capabilityRegistry) ? get_class($capabilityRegistry) : gettype($capabilityRegistry), is_object($capabilityRegistry) ? count($capabilityRegistry->registered) : null]) . "\n");
-    expect($capabilityRegistry->registered)->toHaveCount(9)
+    expect($capabilityRegistry->registered)->toHaveCount(13)
         ->and(collect($capabilityRegistry->registered)->map(fn ($capability) => get_class($capability)))
-        ->toContain(Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability::class);
+        ->toContain(
+            Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\SearchResourcesTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\CreateOrderTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\OptimizeOrderRouteTool::class,
+            Fleetbase\FleetOps\Support\Ai\Tools\ImportOrdersTool::class,
+        );
+
+    $commandRegistry = app(Fleetbase\Ai\Support\Commands\AiCommandRegistry::class);
+    expect(collect($commandRegistry->registered)->pluck('id'))->toContain('fleet-ops.orders.create', 'fleet-ops.settings.map.open');
 
     // The query resources helper registers the fleet-ops queryables directly
     $freshQueryRegistry = new Fleetbase\Ai\Support\AiQueryRegistry();

package/server/tests/Unit/Support/Ai/AssetStatusCapabilityQueriesTest.php

@@ -117,4 +117,46 @@ test('search capability queries scope companies with eager relations', function
         ->and($helper('vehicleSearchQuery')->count())->toBe(0)
         ->and($helper('driverSearchQuery')->count())->toBe(3)
         ->and($helper('genericSearchQuery', Fleetbase\FleetOps\Models\Contact::class)->count())->toBe(0);
+
+    foreach ([Fleetbase\FleetOps\Models\WorkOrder::class, Fleetbase\FleetOps\Models\Maintenance::class, Fleetbase\FleetOps\Models\Device::class, Fleetbase\FleetOps\Models\Sensor::class, Fleetbase\FleetOps\Models\Telematic::class] as $modelClass) {
+        expect($helper('genericSearchQuery', $modelClass))->toBeInstanceOf(Illuminate\Database\Eloquent\Builder::class);
+    }
+});
+
+test('asset status scoped queries resolve a list permission for every supported model', function () {
+    fleetopsAssetStatusCapabilityBoot();
+
+    $capability = (new ReflectionClass(AssetStatusCapability::class))->newInstanceWithoutConstructor();
+    $scoped     = new ReflectionMethod(AssetStatusCapability::class, 'scopedQuery');
+    $scoped->setAccessible(true);
+
+    foreach ([Fleetbase\FleetOps\Models\Vehicle::class, Fleetbase\FleetOps\Models\Device::class, Fleetbase\FleetOps\Models\Sensor::class, Fleetbase\FleetOps\Models\Telematic::class, Fleetbase\FleetOps\Models\Contact::class] as $modelClass) {
+        expect($scoped->invoke($capability, $modelClass))->toBeInstanceOf(Illuminate\Database\Eloquent\Builder::class);
+    }
+});
+
+test('capability queries apply IAM directives for the list permission when the directive macro is available', function () {
+    fleetopsAssetStatusCapabilityBoot();
+
+    if (!Illuminate\Database\Eloquent\Builder::hasGlobalMacro('applyDirectivesForPermissions')) {
+        Illuminate\Database\Eloquent\Builder::macro('applyDirectivesForPermissions', function (string|array $names = []) {
+            $GLOBALS['fleetopsAppliedDirectivePermissions'][] = $names;
+
+            return $this;
+        });
+    }
+
+    $GLOBALS['fleetopsAppliedDirectivePermissions'] = [];
+
+    $capability = (new ReflectionClass(AssetStatusCapability::class))->newInstanceWithoutConstructor();
+    $scope      = new ReflectionMethod(AssetStatusCapability::class, 'scopeToPermission');
+    $scope->setAccessible(true);
+    $plain = new stdClass();
+
+    expect($scope->invoke($capability, $plain, 'fleet-ops list driver'))->toBe($plain);
+
+    $builder = Fleetbase\FleetOps\Models\Driver::query();
+
+    expect($scope->invoke($capability, $builder, 'fleet-ops list driver'))->toBe($builder)
+        ->and($GLOBALS['fleetopsAppliedDirectivePermissions'])->toContain('fleet-ops list driver');
 });

package/server/tests/Unit/Support/Ai/Capabilities/OrderInsightsCapabilityTest.php

@@ -123,6 +123,11 @@ class FleetOpsOrderInsightsCapabilityFake extends OrderInsightsCapability
         return $this->allowed && $permission === 'fleet-ops see order';
     }
 
+    protected function currency(): string
+    {
+        return 'USD';
+    }
+
     protected function orderQuery(?string $companyUuid): mixed
     {
         $this->companies[] = $companyUuid;
@@ -183,6 +188,7 @@ test('order insights resolve returns bounded aggregate order metrics', function
         'authorized'       => true,
         'metric'           => 'orders',
         'amount_threshold' => 125.50,
+        'amount_currency'  => 'USD',
         'count'            => 7,
         'counts_by_status' => ['completed' => 5, 'active' => 2],
         'sample_order_ids' => ['order_1', 'order_2'],
@@ -196,7 +202,7 @@ test('order insights resolve returns bounded aggregate order metrics', function
         ->and($capability->companies)->toBe(['company-123'])
         ->and($capability->query->recordedCalls())->toContain(
             ['whereBetween', 'created_at', [$start, $end]],
-            ['whereHas', 'transaction', [['where', 'amount', '>', 125.50]]],
+            ['whereHas', 'transaction', [['where', 'amount', '>', 12550.0]]],
             ['count'],
             ['selectRaw', 'status, count(*) as aggregate'],
             ['groupBy', 'status'],
@@ -224,3 +230,15 @@ test('order insights resolve omits optional filters when prompt has no date or a
         ->and($capability->query->recordedCalls())->not->toContain(['whereBetween'])
         ->and($capability->query->recordedCalls())->not->toContain(['whereHas']);
 });
+
+test('order insights converts major-unit thresholds using the currency exponent', function () {
+    $capability = new FleetOpsOrderInsightsCapabilityFake();
+    $method     = new ReflectionMethod(OrderInsightsCapability::class, 'toMinorUnits');
+    $method->setAccessible(true);
+
+    expect($method->invoke($capability, 500.0, 'USD'))->toBe(50000)
+        ->and($method->invoke($capability, 125.5, 'usd'))->toBe(12550)
+        ->and($method->invoke($capability, 1000.0, 'JPY'))->toBe(1000)
+        ->and($method->invoke($capability, 1.5, 'BHD'))->toBe(1500)
+        ->and($method->invoke($capability, 10.0, 'NOT-A-CURRENCY'))->toBe(1000);
+});

package/server/tests/Unit/Support/Ai/Capabilities/SearchResourcesCapabilityTest.php

@@ -67,6 +67,17 @@ class FleetOpsSearchResourcesCapabilityProbe extends SearchResourcesCapability
     public array $queries            = [];
     public array $appliedLikes       = [];
 
+    public array $failing = [];
+
+    public function exposeSearchTerms(string $prompt): array
+    {
+        return $this->searchTerms($prompt);
+    }
+
+    protected function reportSearchFailure(string $resource, Throwable $e): void
+    {
+    }
+
     public function exposePromptMatches(string $prompt): bool
     {
         return $this->matchesPrompt($prompt);
@@ -103,6 +114,10 @@ class FleetOpsSearchResourcesCapabilityProbe extends SearchResourcesCapability
 
     protected function genericSearchQuery(string $modelClass)
     {
+        if ($modelClass === Sensor::class && in_array('sensors', $this->failing, true)) {
+            throw new RuntimeException("SQLSTATE[42S22]: Column not found: 1054 Unknown column 'sensor_type'");
+        }
+
         return match ($modelClass) {
             WorkOrder::class   => $this->queries['work_orders'],
             Maintenance::class => $this->queries['maintenances'],
@@ -197,7 +212,7 @@ test('search resources resolve returns authorized resource summaries across all
     $result = $capability->resolve(new AiTask(['prompt' => 'Find order ORDER-1 vehicle VEH-1 driver DRV-1 device DEV-1 sensor SNS-1 telematic TEL-1']));
 
     expect($capability->exposePromptMatches('look up work order WO-1'))->toBeTrue()
-        ->and($result['query_terms'])->toBe(['ORDER-1', 'VEH-1', 'DRV-1', 'device', 'DEV-1', 'sensor'])
+        ->and($result['query_terms'])->toBe(['ORDER-1', 'VEH-1', 'DRV-1', 'DEV-1', 'SNS-1', 'TEL-1'])
         ->and($result['results'])->toHaveKeys(['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'])
         ->and($result['results']['orders'][0])->toMatchArray([
             'id'                   => 'order_public',
@@ -235,3 +250,72 @@ test('search resources resolve returns authorized resource summaries across all
         ->and($capability->queries['orders']->calls)->toContain(['limit', 5], ['get'])
         ->and($capability->appliedLikes)->not->toBeEmpty();
 });
+
+function fleetopsSearchResourcesEmptyQueries(): array
+{
+    return collect(['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'])
+        ->mapWithKeys(fn ($key) => [$key => new FleetOpsSearchResourcesQueryFake()])
+        ->all();
+}
+
+test('search terms ignore ordinary words from real production prompts', function () {
+    $capability = new FleetOpsSearchResourcesCapabilityProbe();
+
+    expect($capability->exposeSearchTerms('i want turn this into a platform where i add cisterns and on a different page BUSINESS leave they orders'))->toBe([])
+        ->and($capability->exposeSearchTerms('Create a few dummy orders so we can test with it'))->toBe([])
+        ->and($capability->exposeSearchTerms('download order import template'))->toBe([])
+        ->and($capability->exposeSearchTerms('config driver app ยังไง'))->toBe([])
+        ->and($capability->exposeSearchTerms('como activar un conductor'))->toBe([]);
+});
+
+test('search terms keep record references such as public ids, plates, emails, quoted and capitalized names', function () {
+    $capability = new FleetOpsSearchResourcesCapabilityProbe();
+
+    expect($capability->exposeSearchTerms('status of order order_yhkejdnzgz'))->toBe(['order_yhkejdnzgz'])
+        ->and($capability->exposeSearchTerms('vehicle plate SBA1234Z'))->toBe(['SBA1234Z'])
+        ->and($capability->exposeSearchTerms('driver with email ada@example.com'))->toBe(['ada@example.com'])
+        ->and($capability->exposeSearchTerms('where is driver Jane Doe right now'))->toBe(['Jane', 'Doe'])
+        ->and($capability->exposeSearchTerms('find "north depot" vehicles'))->toBe(['north depot']);
+});
+
+test('search resources skips querying when the prompt has no record reference', function () {
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->queries            = fleetopsSearchResourcesEmptyQueries();
+
+    $result = $capability->resolve(new AiTask(['prompt' => 'how do I create a new order']));
+
+    expect($result['query_terms'])->toBe([])
+        ->and($result['results'])->toBe([])
+        ->and($capability->appliedLikes)->toBe([]);
+});
+
+test('search resources never searches the dropped sensor_type column or status/uuid columns', function () {
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->queries            = fleetopsSearchResourcesEmptyQueries();
+
+    $capability->resolve(new AiTask(['prompt' => 'find SNS-1']));
+
+    $columns = collect($capability->appliedLikes)->flatMap(fn ($like) => $like[0])->unique()->all();
+
+    expect($columns)->not->toContain('sensor_type')
+        ->and($columns)->not->toContain('status')
+        ->and($columns)->not->toContain('uuid')
+        ->and($columns)->not->toContain('type');
+});
+
+test('a failing resource search does not discard the other results or leak the error', function () {
+    $vehicle = fleetopsSearchResourcesModel(Vehicle::class, ['public_id' => 'vehicle_public', 'uuid' => 'vehicle-uuid', 'name' => 'Van 12']);
+
+    $capability                     = new FleetOpsSearchResourcesCapabilityProbe();
+    $capability->allowedPermissions = $capability->permissions();
+    $capability->failing            = ['sensors'];
+    $capability->queries            = array_merge(fleetopsSearchResourcesEmptyQueries(), ['vehicles' => new FleetOpsSearchResourcesQueryFake([$vehicle])]);
+
+    $result = $capability->resolve(new AiTask(['prompt' => 'find VEH-12']));
+
+    expect($result['results'])->toHaveKey('vehicles')
+        ->and($result['unavailable_search'])->toBe(['sensors'])
+        ->and(json_encode($result))->not->toContain('SQLSTATE');
+});

package/server/tests/Unit/Support/Ai/FleetOpsAiConsoleCommandsTest.php

@@ -0,0 +1,31 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Ai\FleetOpsAiConsoleCommands;
+
+test('fleet-ops console commands are unique, complete, and only navigate or call allowlisted services', function () {
+    $commands = collect(FleetOpsAiConsoleCommands::all());
+
+    expect($commands->pluck('id')->duplicates())->toBeEmpty()
+        ->and($commands->every(fn ($command) => filled($command['label']) && filled($command['breadcrumb']) && filled($command['description']) && !empty($command['steps'])))->toBeTrue()
+        ->and($commands->every(fn ($command) => collect($command['steps'])->every(fn ($step) => $step['type'] === 'navigate'
+            ? str_starts_with($step['route'], 'console.fleet-ops.')
+            : $step['type'] === 'service' && $step['engine'] === FleetOpsAiConsoleCommands::ENGINE && preg_match('/^[a-zA-Z]+$/', $step['method']))))->toBeTrue()
+        ->and($commands->every(fn ($command) => ($command['audience'] ?? 'end_user') === 'end_user'))->toBeTrue();
+});
+
+test('fleet-ops console commands cover create, import, view, and settings', function () {
+    $commands = collect(FleetOpsAiConsoleCommands::all())->keyBy('id');
+
+    expect($commands['fleet-ops.orders.create']['steps'])->toBe([['type' => 'navigate', 'route' => 'console.fleet-ops.operations.orders.index.new']])
+        ->and($commands['fleet-ops.orders.create']['permissions'])->toBe(['fleet-ops create order'])
+        ->and($commands['fleet-ops.orders.import']['steps'][1])->toBe(['type' => 'service', 'engine' => '@fleetbase/fleetops-engine', 'service' => 'order-actions', 'method' => 'importOrders'])
+        ->and($commands['fleet-ops.customers.import']['steps'][1]['service'])->toBe('customer-actions')
+        ->and($commands['fleet-ops.customers.import']['permissions'])->toBe(['fleet-ops import contact'])
+        ->and($commands)->not->toHaveKey('fleet-ops.fleets.import')
+        ->and($commands['fleet-ops.drivers.view']['steps'][0]['models'])->toBe(['public_id'])
+        ->and($commands['fleet-ops.drivers.view']['params'])->toHaveKey('public_id')
+        ->and($commands['fleet-ops.settings.map.open']['steps'][0]['route'])->toBe('console.fleet-ops.settings.map')
+        ->and($commands['fleet-ops.settings.map.open']['permissions'])->toBe(['fleet-ops view map-settings'])
+        ->and($commands['fleet-ops.settings.map.open']['keywords'])->toContain('google maps', 'view maps')
+        ->and($commands['fleet-ops.settings.scheduling.open']['permissions'])->toBe([]);
+});

package/server/tests/Unit/Support/Ai/Tools/FleetOpsAiToolsTest.php

@@ -0,0 +1,246 @@
+<?php
+
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\Ai\Support\AiAudience;
+use Fleetbase\Ai\Support\AiToolContext;
+use Fleetbase\FleetOps\Models\OrderConfig;
+use Fleetbase\FleetOps\Support\Ai\Tools\CreateOrderTool;
+use Fleetbase\FleetOps\Support\Ai\Tools\SearchResourcesTool;
+
+class FleetOpsCreateOrderToolProbe extends CreateOrderTool
+{
+    public array $resolvedPlaces = [];
+
+    public function exposeBuildDraft(AiTask $task, array $input = []): array
+    {
+        return $this->buildDraft($task, $input);
+    }
+
+    protected function can(string $permission): bool
+    {
+        return true;
+    }
+
+    protected function draftFromPrompt(string $prompt): array
+    {
+        return array_filter([
+            'order_config_uuid' => 'order-config-uuid',
+            'type'              => 'transport',
+            'payload'           => $prompt !== '' ? ['pickup_query' => 'Parsed from prompt'] : [],
+            'dispatched'        => false,
+        ], fn ($value) => $value !== []) + ['payload' => []];
+    }
+
+    protected function resolvePlace(?string $query): ?array
+    {
+        return $this->resolvedPlaces[$query] ?? null;
+    }
+
+    protected function resolveOrderConfig(array $draft): ?OrderConfig
+    {
+        $config = new OrderConfig();
+        $config->setRawAttributes(['uuid' => 'order-config-uuid', 'key' => 'transport', 'name' => 'Transport'], true);
+
+        return $config;
+    }
+
+    protected function resolveDriver(array $draft): ?Fleetbase\FleetOps\Models\Driver
+    {
+        return null;
+    }
+
+    protected function resolveVehicle(array $draft): ?Fleetbase\FleetOps\Models\Vehicle
+    {
+        return null;
+    }
+}
+
+class FleetOpsSearchResourcesToolProbe extends SearchResourcesTool
+{
+    public array $searched = [];
+
+    protected function searchAll(array $terms, ?array $types = null): array
+    {
+        $this->searched[] = [$terms, $types];
+
+        return ['query_terms' => $terms, 'results' => []];
+    }
+}
+
+test('create order tool prepares one draft preview per call from structured fields without parsing the prompt', function () {
+    $tool    = new FleetOpsCreateOrderToolProbe();
+    $task    = new AiTask(['prompt' => 'Create some dummy orders with made up data', 'metadata' => []]);
+    $context = new AiToolContext($task, new AiAudience(false, ['fleet-ops create order']));
+
+    $first = $tool->invoke($task, [
+        'pickup'       => 'Kabelweg 57, Amsterdam',
+        'dropoff'      => 'Danzigerkade 15, Amsterdam',
+        'scheduled_at' => '2026-09-16T09:30:00+02:00',
+        'driver'       => '  ',
+        'notes'        => 'Test order',
+    ], $context);
+    $second = $tool->invoke($task, ['pickup' => 'Diemerhof 32, Diemen', 'dropoff' => 'Herikerbergweg 238, Amsterdam', 'dispatch' => true], $context);
+
+    expect($first['preview_id'])->toBe('preview-1')
+        ->and($second['preview_id'])->toBe('preview-2')
+        ->and($first['status'])->toBe('draft_shown_to_user')
+        ->and($first['message'])->toContain('does not exist until the user reviews the card')
+        ->and($context->actionPreviews)->toHaveCount(2)
+        ->and($context->actionPreviews[0]['draft']['payload']['pickup_query'])->toBe('Kabelweg 57, Amsterdam')
+        ->and($context->actionPreviews[0]['draft']['scheduled_at'])->toBe('2026-09-16T09:30:00+02:00')
+        ->and($context->actionPreviews[0]['draft']['notes'])->toBe('Test order')
+        ->and($context->actionPreviews[0]['draft'])->not->toHaveKey('driver_query')
+        ->and($context->actionPreviews[0]['draft']['dispatched'])->toBeFalse()
+        ->and($context->actionPreviews[1]['draft']['payload']['pickup_query'])->toBe('Diemerhof 32, Diemen')
+        ->and($context->actionPreviews[1]['draft']['dispatched'])->toBeTrue()
+        ->and(json_encode($context->actionPreviews))->not->toContain('Parsed from prompt')
+        ->and($tool->toolName())->toBe('propose_create_order')
+        ->and($tool->key())->toBe('fleet-ops.create_order')
+        ->and($tool->toolDescription())->toContain('NOT created by this tool')
+        ->and($tool->toolParameters()['required'])->toBe(['pickup', 'dropoff'])
+        ->and($tool->availableFor($context))->toBeTrue()
+        ->and($tool->availableFor(new AiToolContext($task, new AiAudience(false, []))))->toBeFalse();
+});
+
+test('create order drafts refresh from the edited preview and still parse prompts in keyword mode', function () {
+    $tool = new FleetOpsCreateOrderToolProbe();
+    $task = new AiTask(['prompt' => 'create order', 'metadata' => ['action_previews' => [['draft' => ['notes' => 'first preview']]]]]);
+
+    $refreshed = $tool->exposeBuildDraft($task, ['existing_draft' => ['notes' => 'second preview'], 'draft' => ['dispatched' => true]]);
+    $keyword   = $tool->exposeBuildDraft($task, ['dispatched' => false]);
+
+    expect($refreshed['notes'])->toBe('second preview')
+        ->and($refreshed['dispatched'])->toBeTrue()
+        ->and($refreshed['payload']['pickup_query'])->toBe('Parsed from prompt')
+        ->and($keyword['notes'])->toBe('first preview')
+        ->and($keyword)->not->toHaveKey('existing_draft');
+});
+
+test('search tool searches the requested phrase and identifiers for the chosen record types', function () {
+    $tool    = new FleetOpsSearchResourcesToolProbe();
+    $task    = new AiTask(['prompt' => 'where is Jane']);
+    $context = new AiToolContext($task, new AiAudience(false, ['fleet-ops see driver']));
+
+    $tool->invoke($task, ['query' => 'Jane Doe', 'types' => ['drivers', 'pets']], $context);
+    $tool->invoke($task, ['query' => 'order order_yhkejdnzgz'], $context);
+
+    expect($tool->searched[0])->toBe([['Jane Doe', 'Doe'], ['drivers']])
+        ->and($tool->searched[1])->toBe([['order order_yhkejdnzgz', 'order_yhkejdnzgz'], null])
+        ->and($tool->invoke($task, ['query' => ' x '], $context))->toBe(['error' => 'Provide an identifier or name to search for.'])
+        ->and($tool->toolName())->toBe('fleetops_search')
+        ->and($tool->key())->toBe('fleet-ops.search_resources')
+        ->and($tool->toolDescription())->toContain('particular record')
+        ->and($tool->toolParameters()['properties']['types']['items']['enum'])->toBe(SearchResourcesTool::TYPES)
+        ->and($tool->availableFor($context))->toBeTrue()
+        ->and($tool->availableFor(new AiToolContext($task, new AiAudience(false, []))))->toBeFalse();
+});
+
+test('search tool narrows the real search to the requested types', function () {
+    $tool = new class extends SearchResourcesTool {
+        public array $called = [];
+
+        protected function orders(array $terms): array
+        {
+            $this->called[] = 'orders';
+
+            return [['id' => 'order_1']];
+        }
+
+        protected function drivers(array $terms): array
+        {
+            $this->called[] = 'drivers';
+
+            return [];
+        }
+    };
+
+    $result = $tool->invoke(new AiTask(['prompt' => '']), ['query' => 'ORDER-1', 'types' => ['orders']], new AiToolContext(new AiTask(), new AiAudience(true)));
+
+    expect($tool->called)->toBe(['orders'])
+        ->and($result['results'])->toBe(['orders' => [['id' => 'order_1']]]);
+});
+
+class FleetOpsOptimizeOrderRouteToolProbe extends Fleetbase\FleetOps\Support\Ai\Tools\OptimizeOrderRouteTool
+{
+    public array $previewedPrompts = [];
+
+    public function preview(AiTask $task, array $input = []): array
+    {
+        $this->previewedPrompts[] = $task->prompt;
+
+        return [
+            'action'         => $this->key(),
+            'ready'          => true,
+            'message'        => 'Fleetbase AI prepared an optimized waypoint sequence. Review it before applying.',
+            'missing_fields' => [],
+            'fields'         => [['label' => 'Order', 'value' => 'order_abc']],
+        ];
+    }
+}
+
+test('optimize route tool proposes a reviewable preview for the order the model named', function () {
+    $tool    = new FleetOpsOptimizeOrderRouteToolProbe();
+    $task    = new AiTask(['prompt' => 'can you optimise the route please', 'metadata' => []]);
+    $context = new AiToolContext($task, new AiAudience(false, ['fleet-ops optimize order', 'fleet-ops update-route-for order']));
+
+    $result = $tool->invoke($task, ['order' => 'order_abc'], $context);
+
+    expect($result['preview_id'])->toBe('preview-1')
+        ->and($result['ready'])->toBeTrue()
+        ->and($result['status'])->toBe('proposal_shown_to_user')
+        ->and($result['fields'])->toBe([['label' => 'Order', 'value' => 'order_abc']])
+        ->and($result['missing_fields'])->toBe([])
+        // The capability finds the order in the prompt text, so the tool hands it the id the model gave.
+        ->and($tool->previewedPrompts)->toBe(['order_abc'])
+        ->and($task->prompt)->toBe('can you optimise the route please')
+        ->and($context->actionPreviews)->toHaveCount(1)
+        ->and($tool->toolName())->toBe('propose_optimize_order_route')
+        ->and($tool->key())->toBe('fleet-ops.optimize_order_route')
+        ->and($tool->toolDescription())->toContain('NOT changed by this tool')
+        ->and($tool->toolParameters()['required'])->toBe(['order'])
+        ->and($tool->availableFor($context))->toBeTrue()
+        ->and($tool->availableFor(new AiToolContext($task, new AiAudience(false, ['fleet-ops optimize order']))))->toBeFalse();
+});
+
+test('optimize route tool refuses to build a preview without an order', function () {
+    $tool    = new FleetOpsOptimizeOrderRouteToolProbe();
+    $task    = new AiTask(['prompt' => 'optimise a route', 'metadata' => []]);
+    $context = new AiToolContext($task, new AiAudience(false, ['fleet-ops optimize order', 'fleet-ops update-route-for order']));
+
+    expect($tool->invoke($task, ['order' => '   '], $context))->toBe([
+        'error'   => 'invalid_arguments',
+        'message' => 'An order id is required to optimize a route.',
+    ])
+        ->and($tool->invoke($task, [], $context)['error'])->toBe('invalid_arguments')
+        ->and($context->actionPreviews)->toBe([])
+        ->and($tool->previewedPrompts)->toBe([]);
+});
+
+class FleetOpsImportOrdersToolProbe extends Fleetbase\FleetOps\Support\Ai\Tools\ImportOrdersTool
+{
+    protected function can(string $permission): bool
+    {
+        return true;
+    }
+}
+
+test('import tool reports what an import needs and never claims to have imported anything', function () {
+    $tool    = new FleetOpsImportOrdersToolProbe();
+    $task    = new AiTask(['prompt' => 'can I import orders from a spreadsheet', 'metadata' => []]);
+    $context = new AiToolContext($task, new AiAudience(false, ['fleet-ops import order']));
+
+    $result = $tool->invoke($task, [], $context);
+
+    expect($result['accepted_sources'])->toBe(['xlsx', 'csv'])
+        ->and($result['minimum_columns'])->toContain('pickup address or pickup place')
+        ->and($result['can_import_here'])->toBeFalse()
+        ->and($result['message'])->toContain('will not process uploaded spreadsheets')
+        ->and($context->actionPreviews)->toBe([])
+        ->and($tool->toolName())->toBe('fleetops_import_requirements')
+        ->and($tool->key())->toBe('fleet-ops.import_orders_preview')
+        ->and($tool->toolDescription())->toContain('does NOT import anything')
+        ->and($tool->toolParameters()['properties'])->toBeInstanceOf(stdClass::class)
+        ->and(json_encode($tool->toolParameters()['properties']))->toBe('{}')
+        ->and($tool->availableFor($context))->toBeTrue()
+        ->and($tool->availableFor(new AiToolContext($task, new AiAudience(false, []))))->toBeFalse();
+});