@fleetbase/fleetops-engine 0.6.56 → 0.6.58

package/server/src/Support/Ai/Capabilities/SearchResourcesCapability.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai\Capabilities;
+
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Maintenance;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Sensor;
+use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\WorkOrder;
+
+class SearchResourcesCapability extends AbstractFleetOpsAICapability
+{
+    public function key(): string
+    {
+        return 'fleet-ops.search_resources';
+    }
+
+    public function label(): string
+    {
+        return 'Search Fleet-Ops resources';
+    }
+
+    public function description(): string
+    {
+        return 'Finds relevant Fleet-Ops orders, vehicles, drivers, work orders, maintenances, devices, sensors, and telematics.';
+    }
+
+    public function permissions(): array
+    {
+        return [
+            'fleet-ops see order',
+            'fleet-ops see vehicle',
+            'fleet-ops see driver',
+            'fleet-ops see work-order',
+            'fleet-ops see maintenance',
+            'fleet-ops see device',
+            'fleet-ops see sensor',
+            'fleet-ops see telematic',
+        ];
+    }
+
+    public function resolve(AiTask $task): array
+    {
+        $prompt = (string) $task->prompt;
+        $terms  = $this->searchTerms($prompt);
+
+        return [
+            'query_terms' => $terms,
+            'results'     => array_filter([
+                'orders'       => $this->orders($terms),
+                'vehicles'     => $this->vehicles($terms),
+                'drivers'      => $this->drivers($terms),
+                'work_orders'  => $this->workOrders($terms),
+                'maintenances' => $this->maintenances($terms),
+                'devices'      => $this->devices($terms),
+                'sensors'      => $this->sensors($terms),
+                'telematics'   => $this->telematics($terms),
+            ]),
+        ];
+    }
+
+    protected function matchesPrompt(string $prompt): bool
+    {
+        return $this->containsAny($prompt, ['find', 'show', 'open', 'look up', 'tell me about', 'status of', 'order', 'vehicle', 'driver', 'work order', 'maintenance', 'device', 'sensor', 'telematic']);
+    }
+
+    protected function orders(array $terms): array
+    {
+        if (!$this->can('fleet-ops see order')) {
+            return [];
+        }
+
+        return Order::with(['transaction', 'trackingNumber'])
+            ->where('company_uuid', session('company'))
+            ->where(function ($query) use ($terms) {
+                $this->whereLikeAny($query, ['public_id', 'internal_id', 'uuid', 'status', 'type'], $terms);
+                $query->orWhereHas('trackingNumber', fn ($tracking) => $this->whereLikeAny($tracking, ['tracking_number', 'barcode'], $terms));
+            })
+            ->limit(5)
+            ->get()
+            ->map(fn (Order $order) => [
+                'id'                   => $order->public_id,
+                'uuid'                 => $order->uuid,
+                'tracking'             => $order->tracking,
+                'status'               => $order->status,
+                'type'                 => $order->type,
+                'transaction_amount'   => $order->transaction_amount,
+                'transaction_currency' => $order->transaction_currency,
+                'route'                => 'console.fleet-ops.operations.orders.index.details',
+                'models'               => [$order->public_id ?: $order->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function vehicles(array $terms): array
+    {
+        if (!$this->can('fleet-ops see vehicle')) {
+            return [];
+        }
+
+        return Vehicle::where('company_uuid', session('company'))
+            ->where(fn ($query) => $this->whereLikeAny($query, ['name', 'make', 'model', 'plate_number', 'vin', 'public_id', 'internal_id'], $terms))
+            ->limit(5)
+            ->get()
+            ->map(fn (Vehicle $vehicle) => [
+                'id'       => $vehicle->public_id,
+                'uuid'     => $vehicle->uuid,
+                'name'     => $vehicle->display_name ?: $vehicle->name,
+                'plate'    => $vehicle->plate_number,
+                'status'   => $vehicle->status,
+                'route'    => 'console.fleet-ops.management.vehicles.index.details',
+                'models'   => [$vehicle->public_id ?: $vehicle->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function drivers(array $terms): array
+    {
+        if (!$this->can('fleet-ops see driver')) {
+            return [];
+        }
+
+        return Driver::with('user')
+            ->where('company_uuid', session('company'))
+            ->where(function ($query) use ($terms) {
+                $this->whereLikeAny($query, ['public_id', 'uuid', 'drivers_license_number', 'status'], $terms);
+                $query->orWhereHas('user', fn ($user) => $this->whereLikeAny($user, ['name', 'email', 'phone'], $terms));
+            })
+            ->limit(5)
+            ->get()
+            ->map(fn (Driver $driver) => [
+                'id'     => $driver->public_id,
+                'uuid'   => $driver->uuid,
+                'name'   => data_get($driver, 'user.name'),
+                'status' => $driver->status,
+                'route'  => 'console.fleet-ops.management.drivers.index.details',
+                'models' => [$driver->public_id ?: $driver->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+
+    protected function workOrders(array $terms): array
+    {
+        return $this->generic(WorkOrder::class, 'fleet-ops see work-order', ['public_id', 'uuid', 'code', 'subject', 'status', 'priority'], 'console.fleet-ops.maintenance.work-orders.index.details', $terms);
+    }
+
+    protected function maintenances(array $terms): array
+    {
+        return $this->generic(Maintenance::class, 'fleet-ops see maintenance', ['public_id', 'uuid', 'status', 'type', 'summary', 'notes'], 'console.fleet-ops.maintenance.maintenances.index.details', $terms);
+    }
+
+    protected function devices(array $terms): array
+    {
+        return $this->generic(Device::class, 'fleet-ops see device', ['public_id', 'uuid', 'name', 'device_id', 'imei', 'serial_number', 'status'], 'console.fleet-ops.connectivity.devices.index.details', $terms);
+    }
+
+    protected function sensors(array $terms): array
+    {
+        return $this->generic(Sensor::class, 'fleet-ops see sensor', ['public_id', 'uuid', 'name', 'internal_id', 'serial_number', 'imei', 'type', 'sensor_type', 'status'], 'console.fleet-ops.connectivity.sensors.index.details', $terms);
+    }
+
+    protected function telematics(array $terms): array
+    {
+        return $this->generic(Telematic::class, 'fleet-ops see telematic', ['public_id', 'uuid', 'name', 'provider', 'status'], 'console.fleet-ops.connectivity.telematics.details', $terms);
+    }
+
+    protected function generic(string $modelClass, string $permission, array $columns, string $route, array $terms): array
+    {
+        if (!$this->can($permission)) {
+            return [];
+        }
+
+        return $modelClass::where('company_uuid', session('company'))
+            ->where(fn ($query) => $this->whereLikeAny($query, $columns, $terms))
+            ->limit(5)
+            ->get()
+            ->map(fn ($record) => [
+                'id'     => $record->public_id,
+                'uuid'   => $record->uuid,
+                'name'   => $record->name ?? $record->subject ?? $record->summary ?? $record->description ?? null,
+                'status' => $record->status ?? null,
+                'route'  => $route,
+                'models' => [$record->public_id ?: $record->uuid],
+            ])
+            ->values()
+            ->all();
+    }
+}

package/server/src/Support/Ai/FleetOpsAiQueryResources.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai;
+
+use Fleetbase\Ai\Support\AiQueryableResource;
+use Fleetbase\Ai\Support\AiQueryRegistry;
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Zone;
+
+class FleetOpsAiQueryResources
+{
+    public static function register(AiQueryRegistry $registry): void
+    {
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.drivers',
+            label: 'Fleet-Ops drivers',
+            module: 'fleet-ops',
+            modelClass: Driver::class,
+            permission: 'fleet-ops see driver',
+            aliases: ['drivers', 'driver'],
+            fields: [
+                'online'         => ['column' => 'online', 'type' => 'boolean'],
+                'status'         => ['column' => 'status', 'type' => 'string'],
+                'current_status' => ['column' => 'current_status', 'type' => 'string'],
+                'city'           => ['column' => 'city', 'type' => 'string'],
+                'country'        => ['column' => 'country', 'type' => 'string'],
+                'vehicle_uuid'   => ['column' => 'vehicle_uuid', 'type' => 'uuid'],
+                'updated_at'     => ['column' => 'updated_at', 'type' => 'datetime'],
+                'created_at'     => ['column' => 'created_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'current_status', 'online', 'city', 'country', 'vehicle_uuid'],
+            locationField: 'location',
+            directivePermission: 'fleet-ops list driver',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.vehicles',
+            label: 'Fleet-Ops vehicles',
+            module: 'fleet-ops',
+            modelClass: Vehicle::class,
+            permission: 'fleet-ops see vehicle',
+            aliases: ['vehicles', 'vehicle'],
+            fields: [
+                'online'      => ['column' => 'online', 'type' => 'boolean'],
+                'status'      => ['column' => 'status', 'type' => 'string'],
+                'driver_uuid' => ['column' => 'driver_uuid', 'type' => 'uuid'],
+                'city'        => ['column' => 'city', 'type' => 'string'],
+                'country'     => ['column' => 'country', 'type' => 'string'],
+                'updated_at'  => ['column' => 'updated_at', 'type' => 'datetime'],
+                'created_at'  => ['column' => 'created_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'display_name', 'status', 'online', 'city', 'country', 'driver_uuid'],
+            locationField: 'location',
+            directivePermission: 'fleet-ops list vehicle',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.devices',
+            label: 'Fleet-Ops devices',
+            module: 'fleet-ops',
+            modelClass: Device::class,
+            permission: 'fleet-ops see device',
+            aliases: ['devices', 'device'],
+            fields: [
+                'online'          => ['column' => 'online', 'type' => 'boolean'],
+                'status'          => ['column' => 'status', 'type' => 'string'],
+                'provider'        => ['column' => 'provider', 'type' => 'string'],
+                'telematic_uuid'  => ['column' => 'telematic_uuid', 'type' => 'uuid'],
+                'attachable_uuid' => ['column' => 'attachable_uuid', 'type' => 'uuid'],
+                'last_online_at'  => ['column' => 'last_online_at', 'type' => 'datetime'],
+                'updated_at'      => ['column' => 'updated_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'online', 'provider', 'telematic_uuid', 'attachable_uuid'],
+            directivePermission: 'fleet-ops list device',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.orders',
+            label: 'Fleet-Ops orders',
+            module: 'fleet-ops',
+            modelClass: Order::class,
+            permission: 'fleet-ops see order',
+            aliases: ['orders', 'order'],
+            fields: [
+                'status'                => ['column' => 'status', 'type' => 'string'],
+                'type'                  => ['column' => 'type', 'type' => 'string'],
+                'driver_assigned_uuid'  => ['column' => 'driver_assigned_uuid', 'type' => 'uuid'],
+                'vehicle_assigned_uuid' => ['column' => 'vehicle_assigned_uuid', 'type' => 'uuid'],
+                'created_at'            => ['column' => 'created_at', 'type' => 'datetime'],
+                'scheduled_at'          => ['column' => 'scheduled_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'status', 'type', 'driver_assigned_uuid', 'vehicle_assigned_uuid', 'created_at'],
+            directivePermission: 'fleet-ops list order',
+            maxLimit: 500,
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.fleets',
+            label: 'Fleet-Ops fleets',
+            module: 'fleet-ops',
+            modelClass: Fleet::class,
+            permission: 'fleet-ops see fleet',
+            aliases: ['fleets', 'fleet'],
+            fields: [
+                'status'     => ['column' => 'status', 'type' => 'string'],
+                'task'       => ['column' => 'task', 'type' => 'string'],
+                'updated_at' => ['column' => 'updated_at', 'type' => 'datetime'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'task'],
+            directivePermission: 'fleet-ops list fleet',
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.service_areas',
+            label: 'Fleet-Ops service areas',
+            module: 'fleet-ops',
+            modelClass: ServiceArea::class,
+            permission: 'fleet-ops see service-area',
+            aliases: ['service areas', 'service area', 'service_areas'],
+            fields: [
+                'status'  => ['column' => 'status', 'type' => 'string'],
+                'country' => ['column' => 'country', 'type' => 'string'],
+                'type'    => ['column' => 'type', 'type' => 'string'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'country', 'type'],
+        ));
+
+        $registry->register(new AiQueryableResource(
+            key: 'fleet-ops.zones',
+            label: 'Fleet-Ops zones',
+            module: 'fleet-ops',
+            modelClass: Zone::class,
+            permission: 'fleet-ops see zone',
+            aliases: ['zones', 'zone'],
+            fields: [
+                'status'            => ['column' => 'status', 'type' => 'string'],
+                'service_area_uuid' => ['column' => 'service_area_uuid', 'type' => 'uuid'],
+            ],
+            sampleFields: ['public_id', 'name', 'status', 'service_area_uuid'],
+        ));
+    }
+}

package/server/src/Support/Utils.php

@@ -248,6 +248,10 @@ class Utils extends FleetbaseUtils
             $coordinates = static::extractPointWktFromQueryExpression($coordinates) ?? $coordinates;
         }
 
+        if ($geoJsonPoint = static::pointFromGeoJson($coordinates)) {
+            return $geoJsonPoint;
+        }
+
         if ($coordinates instanceof Point) {
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
@@ -452,6 +456,10 @@ class Utils extends FleetbaseUtils
             return $coordinates;
         }
 
+        if ($geoJsonPoint = static::pointFromGeoJson($coordinates)) {
+            return $geoJsonPoint;
+        }
+
         if (static::isGeoJson($coordinates)) {
             $coordinatesJson = null;
 
@@ -541,6 +549,10 @@ class Utils extends FleetbaseUtils
             $coordinates = $coordinates->location;
         }
 
+        if ($geoJsonPoint = static::pointFromGeoJson($coordinates)) {
+            $coordinates = $geoJsonPoint;
+        }
+
         if ($coordinates instanceof Point) {
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
@@ -639,6 +651,10 @@ class Utils extends FleetbaseUtils
             return $coordinates;
         }
 
+        if ($geoJsonPoint = static::pointFromGeoJson($coordinates)) {
+            return $geoJsonPoint;
+        }
+
         if (is_null($coordinates) || !static::isCoordinates($coordinates)) {
             return new Point(0, 0);
         }
@@ -649,6 +665,42 @@ class Utils extends FleetbaseUtils
         return new Point($latitude, $longitude);
     }
 
+    /**
+     * Resolve direct GeoJSON Point values and Feature-wrapped Point values.
+     */
+    protected static function pointFromGeoJson($coordinates): ?Point
+    {
+        if (is_string($coordinates) && static::isJson($coordinates)) {
+            $coordinates = json_decode($coordinates, true);
+        }
+
+        if (!is_array($coordinates) && !is_object($coordinates)) {
+            return null;
+        }
+
+        if (data_get($coordinates, 'type') === 'Feature') {
+            $coordinates = data_get($coordinates, 'geometry');
+        }
+
+        if (data_get($coordinates, 'type') !== 'Point') {
+            return null;
+        }
+
+        $pointCoordinates = data_get($coordinates, 'coordinates');
+        if (!is_array($pointCoordinates) || count($pointCoordinates) < 2) {
+            return null;
+        }
+
+        $longitude = $pointCoordinates[0];
+        $latitude  = $pointCoordinates[1];
+
+        if (!is_numeric($latitude) || !is_numeric($longitude)) {
+            return null;
+        }
+
+        return new Point((float) $latitude, (float) $longitude);
+    }
+
     /**
      * Converts a point to a WKT (Well-Known Text) representation for SQL insert.
      *

package/server/src/Tracking/TrackingOptions.php

@@ -21,7 +21,12 @@ class TrackingOptions
 
     public static function fromArray(array $options = []): self
     {
-        $systemSettings  = Setting::lookup('fleet-ops.tracking-settings', []);
+        try {
+            $systemSettings = Setting::lookup('fleet-ops.tracking-settings', []);
+        } catch (\Throwable) {
+            $systemSettings = [];
+        }
+
         $config          = array_merge(config('fleetops.tracking', []), is_array($systemSettings) ? $systemSettings : []);
         $companySettings = [];
         try {

package/server/src/routes.php

@@ -302,17 +302,6 @@ Route::prefix(config('fleetops.api.routing.prefix'))->namespace('Fleetbase\Fleet
             });
         });
 
-        /*
-         |--------------------------------------------------------------------------
-         | Publicly Consumable FleetOps API Routes
-         |--------------------------------------------------------------------------
-         |
-         | End-user API routes, these are routes that the SDK and applications will interface with, that DO NOT REQUIRE API credentials.
-         */
-        $router->group(['prefix' => 'v1', 'namespace' => 'Api\v1'], function () use ($router) {
-            $router->get('organizations', 'OrganizationController@listOrganizations');
-        });
-
         /*
          |--------------------------------------------------------------------------
          | Webhook Integration Routes

package/server/tests/AiCreateOrderPreviewCapabilityTest.php

@@ -0,0 +1,131 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\CreateOrderPreviewCapability;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
+use Illuminate\Support\Carbon;
+
+function fleetopsAiCreateOrderCapability()
+{
+    return (new ReflectionClass(CreateOrderPreviewCapability::class))->newInstanceWithoutConstructor();
+}
+
+function fleetopsAiCreateOrderProtectedMethod(string $method): ReflectionMethod
+{
+    $reflection = new ReflectionClass(CreateOrderPreviewCapability::class);
+    $method     = $reflection->getMethod($method);
+    $method->setAccessible(true);
+
+    return $method;
+}
+
+test('create order preview parser extracts pickup and dropoff labels', function (string $prompt, array $expected) {
+    $capability = fleetopsAiCreateOrderCapability();
+    $method     = fleetopsAiCreateOrderProtectedMethod('addressPairFromPrompt');
+
+    expect($method->invoke($capability, $prompt))->toBe($expected);
+})->with([
+    'pickup comma and dropoff' => [
+        'Create an order with the pickup 16 simon walk singapore, and the dropoff 18 hougang ave',
+        ['16 simon walk singapore', '18 hougang ave'],
+    ],
+    'pickup at and drop off to' => [
+        'Create an order pickup at 16 simon walk singapore and drop off to 18 hougang ave',
+        ['16 simon walk singapore', '18 hougang ave'],
+    ],
+    'from to' => [
+        'Create an order from 16 simon walk singapore to 18 hougang ave',
+        ['16 simon walk singapore', '18 hougang ave'],
+    ],
+]);
+
+test('create order preview keeps unresolved addresses as provisional places', function () {
+    $capability = fleetopsAiCreateOrderCapability();
+    $method     = fleetopsAiCreateOrderProtectedMethod('provisionalPlace');
+
+    expect($method->invoke($capability, '16 simon walk singapore'))->toMatchArray([
+        'uuid'      => null,
+        'name'      => '16 simon walk singapore',
+        'address'   => '16 simon walk singapore',
+        'latitude'  => null,
+        'longitude' => null,
+        'source'    => 'unresolved',
+    ]);
+});
+
+test('create order preview serializes coordinates from place location', function () {
+    $capability = fleetopsAiCreateOrderCapability();
+    $method     = fleetopsAiCreateOrderProtectedMethod('serializePlace');
+    $place      = new Place([
+        'name'        => '16 Simon Walk',
+        'street1'     => '16 Simon Walk',
+        'city'        => 'Singapore',
+        'postal_code' => '545870',
+        'location'    => new SpatialPoint(1.3621663, 103.8845049),
+    ]);
+
+    expect($method->invoke($capability, $place, '16 simon walk singapore'))->toMatchArray([
+        'latitude'  => 1.3621663,
+        'longitude' => 103.8845049,
+    ]);
+});
+
+test('create order preview route preview excludes return stops', function () {
+    $capability = fleetopsAiCreateOrderCapability();
+    $method     = fleetopsAiCreateOrderProtectedMethod('routePreview');
+
+    $preview = $method->invoke($capability, [
+        'payload' => [
+            'pickup'  => ['address' => '16 Simon Walk', 'latitude' => 1.3621663, 'longitude' => 103.8845049],
+            'dropoff' => ['address' => '18 Hougang Avenue 8', 'latitude' => 1.3701, 'longitude' => 103.8912],
+            'return'  => ['address' => 'Ignored return', 'latitude' => 1.3, 'longitude' => 103.8],
+        ],
+    ]);
+
+    expect(collect($preview['stops'])->pluck('role')->all())
+        ->toBe(['pickup', 'dropoff'])
+        ->and($preview['coordinates'])->toHaveCount(2);
+});
+
+test('create order apply draft removes embedded places when endpoint uuids exist', function () {
+    $capability = new class extends CreateOrderPreviewCapability {
+        public function sanitizeForTest(array $draft): array
+        {
+            return $this->sanitizeDraftForApply($draft);
+        }
+
+        protected function hasExistingPlaceUuid($uuid): bool
+        {
+            return in_array($uuid, ['pickup_uuid_test', 'dropoff_uuid_test'], true);
+        }
+    };
+
+    $draft = $capability->sanitizeForTest([
+        'payload' => [
+            'pickup_uuid'  => 'pickup_uuid_test',
+            'dropoff_uuid' => 'dropoff_uuid_test',
+            'pickup'       => ['uuid' => 'pickup_uuid_test', 'location' => ['type' => 'Point', 'coordinates' => [103.851, 1.2816]]],
+            'dropoff'      => ['uuid' => 'dropoff_uuid_test', 'location' => ['type' => 'Point', 'coordinates' => [103.8318, 1.3048]]],
+            'return'       => ['location' => ['type' => 'Point', 'coordinates' => [103.8, 1.3]]],
+        ],
+    ]);
+
+    expect($draft['payload'])->toHaveKeys(['pickup_uuid', 'dropoff_uuid', 'return'])
+        ->and($draft['payload'])->not->toHaveKeys(['pickup', 'dropoff']);
+});
+
+test('create order preview resolves relative schedule phrases', function () {
+    $timezone = date_default_timezone_get();
+    date_default_timezone_set('Asia/Singapore');
+    Carbon::setTestNow(Carbon::parse('2026-06-30 15:00:00', 'Asia/Singapore'));
+
+    try {
+        $capability = fleetopsAiCreateOrderCapability();
+        $method     = fleetopsAiCreateOrderProtectedMethod('scheduledAtFromPrompt');
+
+        expect($method->invoke($capability, 'Create an order scheduled for 3 days from now'))->toBe('2026-07-03T15:00:00+08:00');
+    } finally {
+        Carbon::setTestNow();
+        date_default_timezone_set($timezone);
+    }
+});

package/server/tests/AiOperationalQueryCapabilityTest.php

@@ -0,0 +1,75 @@
+<?php
+
+use Fleetbase\Ai\Support\AiQueryRegistry;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\AssetStatusCapability;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\OperationalQueryCapability;
+use Fleetbase\FleetOps\Support\Ai\FleetOpsAiQueryResources;
+use Illuminate\Support\Carbon;
+
+function fleetopsAiOperationalCapability()
+{
+    return (new ReflectionClass(OperationalQueryCapability::class))->newInstanceWithoutConstructor();
+}
+
+function fleetopsAiOperationalProtectedMethod(string $method): ReflectionMethod
+{
+    $reflection = new ReflectionClass(OperationalQueryCapability::class);
+    $method     = $reflection->getMethod($method);
+    $method->setAccessible(true);
+
+    return $method;
+}
+
+test('fleet-ops registers safe ai query resources', function () {
+    $registry = new AiQueryRegistry();
+
+    FleetOpsAiQueryResources::register($registry);
+
+    expect($registry->find('drivers')->key)->toBe('fleet-ops.drivers')
+        ->and($registry->find('orders')->hasField('driver_assigned_uuid'))->toBeTrue()
+        ->and($registry->find('devices')->hasField('online'))->toBeTrue()
+        ->and($registry->find('service area')->key)->toBe('fleet-ops.service_areas');
+});
+
+test('operational query capability matches common fleet-ops data questions', function (string $prompt) {
+    $capability = fleetopsAiOperationalCapability();
+    $method     = fleetopsAiOperationalProtectedMethod('matchesPrompt');
+
+    expect($method->invoke($capability, strtolower($prompt)))->toBeTrue();
+})->with([
+    'How many drivers are currently online?',
+    'Where are most of my drivers located?',
+    'How many vehicles were online yesterday?',
+    'Which service area has the most online drivers?',
+    'Show me drivers without vehicles.',
+    'How many active orders have no assigned driver?',
+    'Break down orders by status for this month.',
+]);
+
+test('asset status capability includes driver online prompts', function () {
+    $capability = (new ReflectionClass(AssetStatusCapability::class))->newInstanceWithoutConstructor();
+    $method     = (new ReflectionClass(AssetStatusCapability::class))->getMethod('matchesPrompt');
+    $method->setAccessible(true);
+
+    expect($method->invoke($capability, 'how many drivers are online'))->toBeTrue();
+});
+
+test('operational query date filters use resolved local windows', function () {
+    $timezone = date_default_timezone_get();
+    date_default_timezone_set('Asia/Singapore');
+    Carbon::setTestNow(Carbon::parse('2026-06-30 15:00:00', 'Asia/Singapore'));
+
+    try {
+        $capability = fleetopsAiOperationalCapability();
+        $method     = fleetopsAiOperationalProtectedMethod('orderDateFilters');
+        $filters    = $method->invoke($capability, 'How many orders were created last week?');
+
+        expect($filters)->toHaveCount(2)
+            ->and($filters[0])->toMatchArray(['field' => 'created_at', 'operator' => '>='])
+            ->and($filters[0]['value']->toIso8601String())->toBe('2026-06-22T00:00:00+08:00')
+            ->and($filters[1]['value']->toIso8601String())->toBe('2026-06-28T23:59:59+08:00');
+    } finally {
+        Carbon::setTestNow();
+        date_default_timezone_set($timezone);
+    }
+});