Merge branch 'feature/v2.5.0' into hawk/testing

# Conflicts:
#	app/Http/Middleware/Api/ApiDataScopeContextSettingMiddleware.php
#	app/Services/Users/Keychain/Repositories/UserKeychainRepository.php
#	public/js/groupchat_functions.js
#	public/js/home_functions.js
#	resources/js/bootstrap.ts
#	resources/js/components/chat/composer/contexts/ComposerContext.svelte.ts
#	resources/js/oldUi/OldUiBridge.svelte.ts
#	resources/js/snippets/ChatSidebarButton.svelte
#	resources/js/utils/Bootstrapper.ts
#	resources/views/layouts/apps_layout.blade.php
#	resources/views/layouts/print_template.blade.php

Author: Neunerlei

app/Http/Controllers/HomeController.php

@@ -33,7 +33,19 @@ public function index(
 
         $userData = [
             'convs' => $user->conversations()->with('messages')->get(),
-            'rooms' => $user->rooms()->with('messages')->get(),
+            'rooms' => $user->rooms()->with('messages')->get()->map(function ($room) use ($user) {
+                $member = $room->members()->where('user_id', $user->id)->first();
+
+                $raw = $room->toArray();
+                $raw['hasUnreadMessages'] = false;
+                foreach ($room->messages as $message) {
+                    if (!$message->isReadBy($member)) {
+                        $raw['hasUnreadMessages'] = true;
+                        break;
+                    }
+                }
+                return $raw;
+            })->toArray()
         ];
 
         $activeModule = $requestModule;

app/Http/Controllers/StreamController.php

@@ -330,26 +330,58 @@ private function handleGroupChatRequest(array $data, Request $request): void
         ];
         broadcast(new RoomMessageEvent($generationStatus));
 
+        $data['payload']['broadcast'] = true; // Ensure broadcast is enabled for group chat requests
+        $data['payload']['stream'] = false; // Ensure streaming is disabled for group chat requests
+        try {
+            $agentRequest = $this->aiService->getAgentRequestFactory()->createFromPayload($data['payload']);
+        } catch (\Throwable $e) {
+            $this->logger->error('Error creating agent request from payload', ['exception' => $e]);
+            try {
+                $model = $this->aiService->getModels()->findOneOrFail($data['payload']['model']);
+                RoomAiWritingEndedEvent::dispatch($room, $model);
+            } catch (\Throwable) {
+            }
+            abort(400, 'Invalid payload for agent request.');
+        }
+
         // Process the request
-        $response = $this->aiService->sendRequestToAgent($data['payload']);
+        try {
+            $response = $this->aiService->sendRequestToAgent($agentRequest);
+        } catch (\Throwable $e) {
+            $this->logger->error('Error sending request to agent', ['exception' => $e]);
+            $response = new ChatResponse(
+                content: 'NT: Sorry, but there was an error processing your request. Please try again later.',
+            );
+        }
+
+        if (!$response instanceof ChatResponse) {
+            $this->logger->error('Unexpected response type from agent', ['response' => $response]);
+            try {
+                $model = $this->aiService->getModels()->findOneOrFail($data['payload']['model']);
+                RoomAiWritingEndedEvent::dispatch($room, $model);
+            } catch (\Throwable) {
+            }
+            abort(500, 'Unexpected response type from agent.');
+        }
 
         // Record usage
-        $this->usageAnalyzer->submitUsageRecord(
-            $response->usage,
-            'group',
-            $room->id
-        );
+//        $this->usageAnalyzer->submitUsageRecord(
+//            $response->usage,
+//            'group',
+//            $room->id
+//        );
 
         // @todo this was         $crypto = new SymmetricCrypto();
         //        $encryptedData = $crypto->encrypt($response->content['text'],
         //                                          base64_decode($data['key']));
         $content = $response->content;
-        if (array_key_exists('groundingMetadata', $response->content)) {
-            $content = json_encode([
-                'text' => $response->content['text'],
-                'groundingMetadata' => $response->content['groundingMetadata'],
-            ]);
-        }
+//        $content = $response->content;
+//        if (array_key_exists('groundingMetadata', $response->content)) {
+//            $content = json_encode([
+//                'text' => $response->content['text'],
+//                'groundingMetadata' => $response->content['groundingMetadata'],
+//            ]);
+//        }
 //        \Log::debug($content);
         $encryptedData = (new SymmetricCrypto())->encrypt(json_encode($content), base64_decode($data['key']));
 

app/Http/Middleware/Api/ApiDataScopeContextSettingMiddleware.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Middleware\Api;
 
+use App\Services\System\Container\ServiceLocator;
 use Closure;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Http\Request;
@@ -12,20 +13,27 @@
     public const string NO_SCOPE_PARAM = 'no_scope';
 
     public function __construct(
-        private Server|null $jsonApiServer
+        // Use a service locator here, because otherwise we end up getting errors about not being able to create the Server instance
+        // This is because the server is only bound by another middleware and therefore when the stack is resolved,
+        // the server is not yet available in the container.
+        private ServiceLocator $serviceLocator
     )
     {
     }
 
     public function handle(Request $request, Closure $next)
     {
-        if ($this->jsonApiServer) {
-            $this->populateContextByRequest($request);
+        try {
+            $apiServer = $this->serviceLocator->get(Server::class);
+        } catch (\Throwable) {
+            return $next($request);
         }
+
+        $this->populateContextByRequest($request, $apiServer);
         return $next($request);
     }
 
-    private function populateContextByRequest(Request $request): void
+    private function populateContextByRequest(Request $request, Server $apiServer): void
     {
         $noScope = $request->query(self::NO_SCOPE_PARAM);
         if (!is_array($noScope)) {
@@ -34,7 +42,7 @@ private function populateContextByRequest(Request $request): void
 
         $findMostSimilar = static fn(string $input, array $options): string => collect($options)->sortBy(fn(string $item) => levenshtein($input, $item))->first();
 
-        $schemaContainer = $this->jsonApiServer->schemas();
+        $schemaContainer = $apiServer->schemas();
         foreach ($noScope as $resourceType => $scopeKey) {
             if (!is_string($resourceType)) {
                 abort(400, sprintf('Invalid resource type in "%s" query parameter. Expected string keys in format no_scope[resource-type]=scopeKey', self::NO_SCOPE_PARAM));

app/Models/Invitation.php

@@ -28,7 +28,7 @@ class Invitation extends Model
      */
     public function room(): BelongsTo
     {
-        return $this->belongsTo(Room::class);
+        return $this->belongsTo(Room::class)->withoutGlobalScopes();
     }
 
     /**

app/Models/Room.php

@@ -14,6 +14,7 @@
 use App\Services\Storage\Values\StoredFileIdentifier;
 use App\Services\System\Database\Eloquent\ContextualScopes\HasContextualScopesTrait;
 use App\Services\System\Database\Eloquent\ContextualScopes\ScopeRegistrar;
+use App\Services\Users\Keychain\Repositories\UserKeychainRepository;
 use Exception;
 use Illuminate\Database\Eloquent\Attributes\UsePolicy;
 use Illuminate\Database\Eloquent\Model;
@@ -166,12 +167,25 @@ public function removeMember(int $userId): bool
                 // Attempt to delete the member from the room based on user ID
                 $member = $this->members()->where('user_id', $userId)->firstOrFail();
                 $member->revokeMembership();
+                // Please don't do it like this. Don't torture your model with injecting
+                // random repositories. There should be a service, but the service itself is cumbersome.
+                // Will be removed in a future refactor.
+                /** @var UserKeychainRepository $repo */
+                $repo = app(UserKeychainRepository::class);
+                $repo->removeRoomKey($member->user, $member->room);
 
                 $this->triggerOrDeferMemberEvent(fn() => MemberRemovedFromRoomEvent::dispatch($member));
 
                 //Check if All the members have left the room.
                 if ($this->members()->count() === 1) {
                     $this->deleteRoom();
+                } else if ($member->hasRole(Member::ROLE_ADMIN)) {
+                    // If the removed member was an admin, check if there are any admins left. If not, handle this as a "delete" action
+                    // @todo in the new api it should not be possible to leave a room without at least one admin!
+                    $adminsCount = $this->members()->where('role', Member::ROLE_ADMIN)->count();
+                    if ($adminsCount === 0) {
+                        $this->delete();
+                    }
                 }
                 return true;
             } catch (\Throwable $e) {

app/Models/Scopes/KnownUsersAccessScope.php

@@ -20,23 +20,18 @@ class KnownUsersAccessScope implements Scope
      */
     public function apply(EloquentBuilder $builder, Model $model): void
     {
-        try {
-            $this->runIfUserPresent(
-                function (User $user) use ($builder) {
-                    $builder
-                        // Allow all users to see records of groupchats they are a member of
-                        ->whereHas('members', function (EloquentBuilder $query) use ($user) {
-                            $query->where('user_id', $user->id);
-                        })
-                        // Allow users to see their own record, even if they are not a member of any team
-                        ->orWhere('users.id', $user->id)
-                        // Allow all users to see the HAWKI user record
-                        ->orWhere('users.id', 1);
-                },
-                callbackNoUserInCli: true
-            );
-        } catch (\Throwable $e) {
-            dbge($e);
-        }
+        $this->runIfUserPresent(
+            function (User $user) use ($builder) {
+                $builder
+                    // Allow all users to see records of groupchats they are a member of
+                    ->whereHas('members')
+                    // Allow users to see their own record, even if they are not a member of any team
+                    ->orWhere('users.id', $user->id)
+                    // Allow all users to see the HAWKI user record
+
+                    ->orWhere('users.id', 1);
+            },
+            callbackNoUserInCli: true
+        );
     }
 }

app/Services/Ai/Agent/Chat/ChatRequestFactory.php

@@ -187,7 +187,10 @@ private function addAttachmentsToMessage(
     {
         foreach ($attachmentUuids as $uuid) {
             $file = $this->fileStorageService->retrieve(StoredFileIdentifier::fromCategoryAndUuid($category, $uuid));
-            $extracts = ($file->getExtracts()?->count() ?? 0) > 0 ? $file->getExtracts() : [$file];
+            if (!$file) {
+                logFile($category, $uuid, 'File not found for attachment.', $message, $attachmentUuids);
+            }
+            $extracts = ($file?->getExtracts()?->count() ?? 0) > 0 ? $file->getExtracts() : [$file];
             foreach ($extracts as $extract) {
                 if ($extract->getFileType() === FileType::IMAGE) {
                     $message->addContent(new ImageContent(

app/Services/Chat/Room/Traits/RoomFunctions.php

@@ -119,10 +119,6 @@ public function delete($slug)
     {
         $room = Room::where('slug', $slug)->firstOrFail();
 
-        if (!$room->isMember(Auth::id())) {
-            throw new AuthorizationException();
-        }
-
         try {
             $room->deleteRoom();
             return true;

app/Services/Chat/Room/Traits/RoomMembers.php

@@ -69,12 +69,6 @@ public function removeMember(Member $member, Room $room): bool
     {
         // Remove the member from the room
         $room->removeMember($member->user_id);
-
-        //Check if All the members have left the room.
-        if ($room->members()->count() === 1) {
-            $this->delete($room->slug);
-        }
-
         return true;
     }
 
@@ -83,6 +77,7 @@ public function searchUser(string $query): array
     {
         // Search in the database for users matching the query and is not removed
         $users = User::where('isRemoved', false)
+            ->withoutGlobalScopes()
             ->where(function ($queryBuilder) use ($query) {
                 $queryBuilder->where('name', 'like', "%{$query}%")
                     ->orWhere('username', 'like', "%{$query}%")

app/Services/Users/Keychain/Repositories/UserKeychainRepository.php

@@ -5,6 +5,7 @@
 namespace App\Services\Users\Keychain\Repositories;
 
 
+use App\Models\Room;
 use App\Models\User;
 use App\Models\UserKeychainValue;
 use App\Services\System\Database\Eloquent\Repositories\AbstractRepositoryWithContextualScopes;
@@ -113,6 +114,26 @@ public function findFirstPublicKeyOfUser(User $user): ?UserKeychainValue
             ->first();
     }
 
+    /**
+     * Removes all room keys for a user for a given room.
+     * This should be called when a user is removed from a room to ensure they no longer have access to the room's key.
+     * @param User $user
+     * @param Room $room
+     * @return void
+     */
+    public function removeRoomKey(User $user, Room $room): void
+    {
+        $this->getQueryWithoutContextualScopes('access')
+            ->where('user_id', $user->id)
+            ->whereIn('type', [
+                UserKeychainValueType::ROOM->value,
+                UserKeychainValueType::ROOM_AI->value,
+                UserKeychainValueType::ROOM_AI_LEGACY->value
+            ])
+            ->where('key', $room->slug)
+            ->each(fn(UserKeychainValue $val) => $val->delete());
+    }
+
     /**
      * A basic housekeeping method that removes all room keys for rooms the user is no longer a member of.
      * This should be run once in a while to keep the database clean.