@lobehub/lobehub 2.0.0-next.310 → 2.0.0-next.312

package/src/features/Conversation/ChatList/components/VirtualizedList.tsx

@@ -30,7 +30,9 @@ const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent })
   const setScrollState = useConversationStore((s) => s.setScrollState);
   const resetVisibleItems = useConversationStore((s) => s.resetVisibleItems);
   const scrollToBottom = useConversationStore((s) => s.scrollToBottom);
+  const setActiveIndex = useConversationStore((s) => s.setActiveIndex);
   const atBottom = useConversationStore(virtuaListSelectors.atBottom);
+  const activeIndex = useConversationStore(virtuaListSelectors.activeIndex);
 
   // Check if at bottom based on scroll position
   const checkAtBottom = useCallback(() => {
@@ -46,6 +48,16 @@ const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent })
 
   // Handle scroll events
   const handleScroll = useCallback(() => {
+    const refForActive = virtuaRef.current;
+    const activeFromFindRaw =
+      refForActive && typeof refForActive.findItemIndex === 'function'
+        ? refForActive.findItemIndex(refForActive.scrollOffset + refForActive.viewportSize * 0.25)
+        : null;
+    const activeFromFind =
+      typeof activeFromFindRaw === 'number' && activeFromFindRaw >= 0 ? activeFromFindRaw : null;
+
+    if (activeFromFind !== activeIndex) setActiveIndex(activeFromFind);
+
     setScrollState({ isScrolling: true });
 
     // Check if at bottom
@@ -61,7 +73,7 @@ const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent })
     scrollEndTimerRef.current = setTimeout(() => {
       setScrollState({ isScrolling: false });
     }, 150);
-  }, [checkAtBottom, setScrollState]);
+  }, [activeIndex, checkAtBottom, setActiveIndex, setScrollState]);
 
   const handleScrollEnd = useCallback(() => {
     setScrollState({ isScrolling: false });
@@ -77,12 +89,18 @@ const VirtualizedList = memo<VirtualizedListProps>(({ dataSource, itemContent })
         getViewportSize: () => ref.viewportSize,
         scrollToIndex: (index, options) => ref.scrollToIndex(index, options),
       });
+
+      // Seed active index once on mount (avoid requiring user scroll)
+      const initialActiveRaw = ref.findItemIndex(ref.scrollOffset + ref.viewportSize * 0.25);
+      const initialActive =
+        typeof initialActiveRaw === 'number' && initialActiveRaw >= 0 ? initialActiveRaw : null;
+      setActiveIndex(initialActive);
     }
 
     return () => {
       registerVirtuaScrollMethods(null);
     };
-  }, [registerVirtuaScrollMethods]);
+  }, [registerVirtuaScrollMethods, setActiveIndex]);
 
   // Cleanup on unmount
   useEffect(() => {

package/src/features/Conversation/store/slices/virtuaList/action.ts

@@ -32,6 +32,11 @@ export interface VirtuaListAction {
     options?: { align?: 'start' | 'center' | 'end'; smooth?: boolean },
   ) => void;
 
+  /**
+   * Set active index directly (derived from scroll position)
+   */
+  setActiveIndex: (index: number | null) => void;
+
   /**
    * Update scroll state (atBottom, isScrolling)
    */
@@ -107,6 +112,10 @@ export const virtuaListSlice: StateCreator<State & VirtuaListAction, [], [], Vir
     virtuaScrollMethods?.scrollToIndex(index, options);
   },
 
+  setActiveIndex: (index) => {
+    set({ activeIndex: index });
+  },
+
   setScrollState: (state) => {
     set(state);
   },

package/src/features/Electron/navigation/routeMetadata.ts

@@ -79,7 +79,7 @@ const routePatterns: RoutePattern[] = [
   // Community/Discover routes
   {
     icon: Compass,
-    test: (p) => p.startsWith('/community/assistant'),
+    test: (p) => p.startsWith('/community/agent'),
     titleKey: 'navigation.discoverAssistants',
   },
   {

package/src/layout/GlobalProvider/FaviconProvider.tsx

@@ -0,0 +1,92 @@
+'use client';
+
+import { type ReactNode, createContext, memo, useCallback, useContext, useState } from 'react';
+
+export type FaviconState = 'default' | 'done' | 'error' | 'progress';
+
+interface FaviconContextValue {
+  currentState: FaviconState;
+  isDevMode: boolean;
+  setFavicon: (state: FaviconState) => void;
+  setIsDevMode: (isDev: boolean) => void;
+}
+
+const FaviconContext = createContext<FaviconContextValue | null>(null);
+
+export const useFavicon = () => {
+  const context = useContext(FaviconContext);
+  if (!context) {
+    throw new Error('useFavicon must be used within FaviconProvider');
+  }
+  return context;
+};
+
+const stateToFileName: Record<FaviconState, string> = {
+  default: '',
+  done: '-done',
+  error: '-error',
+  progress: '-progress',
+};
+
+const getFaviconPath = (state: FaviconState, isDev: boolean, size?: '32x32'): string => {
+  const devSuffix = isDev ? '-dev' : '';
+  const stateSuffix = stateToFileName[state];
+  const sizeSuffix = size ? `-${size}` : '';
+  return `/favicon${sizeSuffix}${stateSuffix}${devSuffix}.ico`;
+};
+
+const updateFaviconDOM = (state: FaviconState, isDev: boolean) => {
+  if (typeof document === 'undefined') return;
+
+  const head = document.head;
+  const existingLinks = document.querySelectorAll<HTMLLinkElement>(
+    'link[rel="icon"], link[rel="shortcut icon"]',
+  );
+
+  // Remove existing favicon links and create new ones to bust cache
+  existingLinks.forEach((link) => {
+    const oldHref = link.href;
+    const is32 = oldHref.includes('32x32');
+    const rel = link.rel;
+
+    // Remove old link
+    link.remove();
+
+    // Create new link with cache-busting query param
+    const newLink = document.createElement('link');
+    newLink.rel = rel;
+    newLink.href = `${getFaviconPath(state, isDev, is32 ? '32x32' : undefined)}?v=${Date.now()}`;
+    head.append(newLink);
+  });
+};
+
+const defaultIsDev = process.env.NODE_ENV === 'development';
+
+export const FaviconProvider = memo<{ children: ReactNode }>(({ children }) => {
+  const [currentState, setCurrentState] = useState<FaviconState>('default');
+  const [isDevMode, setIsDevModeState] = useState<boolean>(defaultIsDev);
+
+  const setFavicon = useCallback(
+    (state: FaviconState) => {
+      setCurrentState(state);
+      updateFaviconDOM(state, isDevMode);
+    },
+    [isDevMode],
+  );
+
+  const setIsDevMode = useCallback(
+    (isDev: boolean) => {
+      setIsDevModeState(isDev);
+      updateFaviconDOM(currentState, isDev);
+    },
+    [currentState],
+  );
+
+  return (
+    <FaviconContext.Provider value={{ currentState, isDevMode, setFavicon, setIsDevMode }}>
+      {children}
+    </FaviconContext.Provider>
+  );
+});
+
+FaviconProvider.displayName = 'FaviconProvider';

package/src/layout/GlobalProvider/index.tsx

@@ -14,6 +14,7 @@ import { ServerConfigStoreProvider } from '@/store/serverConfig/Provider';
 import { getAntdLocale } from '@/utils/locale';
 
 import AppTheme from './AppTheme';
+import { FaviconProvider } from './FaviconProvider';
 import { GroupWizardProvider } from './GroupWizardProvider';
 import ImportSettings from './ImportSettings';
 import Locale from './Locale';
@@ -65,17 +66,20 @@ const GlobalLayout = async ({
             >
               <QueryProvider>
                 <StoreInitialization />
-                <GroupWizardProvider>
-                  <DragUploadProvider>
-                    <LazyMotion features={domMax}>
-                      <TooltipGroup layoutAnimation={false}>
-                        <LobeAnalyticsProviderWrapper>{children}</LobeAnalyticsProviderWrapper>
-                      </TooltipGroup>
-                      <ModalHost />
-                      <ContextMenuHost />
-                    </LazyMotion>
-                  </DragUploadProvider>
-                </GroupWizardProvider>
+                <FaviconProvider>
+                  {/* {process.env.NODE_ENV === 'development' && <FaviconTestPanel />} */}
+                  <GroupWizardProvider>
+                    <DragUploadProvider>
+                      <LazyMotion features={domMax}>
+                        <TooltipGroup layoutAnimation={false}>
+                          <LobeAnalyticsProviderWrapper>{children}</LobeAnalyticsProviderWrapper>
+                        </TooltipGroup>
+                        <ModalHost />
+                        <ContextMenuHost />
+                      </LazyMotion>
+                    </DragUploadProvider>
+                  </GroupWizardProvider>
+                </FaviconProvider>
               </QueryProvider>
               <Suspense>
                 {ENABLE_BUSINESS_FEATURES ? <ReferralProvider /> : null}

package/src/libs/next/config/define-config.ts

@@ -267,7 +267,7 @@ export function defineConfig(config: CustomNextConfig) {
         source: '/manifest.json',
       },
       {
-        destination: '/community/assistant',
+        destination: '/community/agent',
         permanent: true,
         source: '/community/assistants',
       },

package/src/libs/trpc/lambda/middleware/marketSDK.ts

@@ -1,6 +1,5 @@
-import { MarketSDK } from '@lobehub/market-sdk';
-
-import { generateTrustedClientToken, type TrustedClientUserInfo } from '@/libs/trusted-client';
+import { type TrustedClientUserInfo } from '@/libs/trusted-client';
+import { MarketService } from '@/server/services/market';
 
 import { trpc } from '../init';
 
@@ -10,53 +9,45 @@ interface ContextWithMarketUserInfo {
 }
 
 /**
- * Middleware that initializes MarketSDK with proper authentication.
+ * Middleware that initializes MarketService with proper authentication.
  * This requires marketUserInfo middleware to be applied first.
  *
  * Provides:
- * - ctx.marketSDK: Initialized MarketSDK instance with trustedClientToken and optional accessToken
- * - ctx.trustedClientToken: The generated trusted client token (if available)
+ * - ctx.marketSDK: MarketSDK instance for backward compatibility
+ * - ctx.marketService: MarketService instance (recommended)
  */
 export const marketSDK = trpc.middleware(async (opts) => {
   const ctx = opts.ctx as ContextWithMarketUserInfo;
 
-  // Generate trusted client token if user info is available
-  const trustedClientToken = ctx.marketUserInfo
-    ? generateTrustedClientToken(ctx.marketUserInfo)
-    : undefined;
-
-  // Initialize MarketSDK with both authentication methods
-  const market = new MarketSDK({
+  // Initialize MarketService with authentication
+  const marketService = new MarketService({
     accessToken: ctx.marketAccessToken,
-    baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
-    trustedClientToken,
+    userInfo: ctx.marketUserInfo,
   });
 
   return opts.next({
     ctx: {
-      marketSDK: market,
-      trustedClientToken,
+      marketSDK: marketService.market, // Backward compatibility
+      marketService, // New recommended way
     },
   });
 });
 
 /**
  * Middleware that requires authentication for Market API access.
- * This middleware ensures that either accessToken or trustedClientToken is available.
+ * This middleware ensures that either accessToken or marketUserInfo is available.
  * It should be used after marketUserInfo and marketSDK middlewares.
  *
  * Throws UNAUTHORIZED error if neither authentication method is available.
  */
 export const requireMarketAuth = trpc.middleware(async (opts) => {
-  const ctx = opts.ctx as ContextWithMarketUserInfo & {
-    trustedClientToken?: string;
-  };
+  const ctx = opts.ctx as ContextWithMarketUserInfo;
 
   // Check if any authentication is available
   const hasAccessToken = !!ctx.marketAccessToken;
-  const hasTrustedToken = !!ctx.trustedClientToken;
+  const hasUserInfo = !!ctx.marketUserInfo;
 
-  if (!hasAccessToken && !hasTrustedToken) {
+  if (!hasAccessToken && !hasUserInfo) {
     const { TRPCError } = await import('@trpc/server');
     throw new TRPCError({
       code: 'UNAUTHORIZED',

package/src/libs/trusted-client/index.ts

@@ -3,7 +3,7 @@ import { buildTrustedClientPayload, createTrustedClientToken } from '@lobehub/ma
 import { appEnv } from '@/envs/app';
 
 export interface TrustedClientUserInfo {
-  email: string;
+  email?: string;
   name?: string;
   userId: string;
 }

package/src/server/routers/lambda/market/index.ts

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { DiscoverService } from '@/server/services/discover';
+import { MarketService } from '@/server/services/market';
 import {
   AssistantSorts,
   McpConnectionType,
@@ -37,6 +38,10 @@ const marketProcedure = publicProcedure
           accessToken: ctx.marketAccessToken,
           userInfo: ctx.marketUserInfo,
         }),
+        marketService: new MarketService({
+          accessToken: ctx.marketAccessToken,
+          userInfo: ctx.marketUserInfo,
+        }),
       },
     });
   });

package/src/server/routers/lambda/market/oidc.ts

@@ -1,18 +1,29 @@
-import { MarketSDK } from '@lobehub/market-sdk';
 import { TRPCError } from '@trpc/server';
 import debug from 'debug';
 import { z } from 'zod';
 
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
-import { generateTrustedClientToken } from '@/libs/trusted-client';
+import { MarketService } from '@/server/services/market';
 
 const log = debug('lambda-router:market:oidc');
 
-const MARKET_BASE_URL = process.env.NEXT_PUBLIC_MARKET_BASE_URL || 'https://market.lobehub.com';
-
 // OIDC procedures are public (used during authentication flow)
-const oidcProcedure = publicProcedure.use(serverDatabase).use(marketUserInfo);
+const oidcProcedure = publicProcedure
+  .use(serverDatabase)
+  .use(marketUserInfo)
+  .use(async ({ ctx, next }) => {
+    // Initialize MarketService (may be without auth for public endpoints)
+    const marketService = new MarketService({
+      userInfo: ctx.marketUserInfo,
+    });
+
+    return next({
+      ctx: {
+        marketService,
+      },
+    });
+  });
 
 export const oidcRouter = router({
   /**
@@ -28,19 +39,11 @@ export const oidcRouter = router({
         redirectUri: z.string(),
       }),
     )
-    .mutation(async ({ input }) => {
+    .mutation(async ({ input, ctx }) => {
       log('exchangeAuthorizationCode input: %O', { ...input, code: '[REDACTED]' });
 
-      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
-
       try {
-        const response = await market.auth.exchangeOAuthToken({
-          clientId: input.clientId,
-          code: input.code,
-          codeVerifier: input.codeVerifier,
-          grantType: 'authorization_code',
-          redirectUri: input.redirectUri,
-        });
+        const response = await ctx.marketService.exchangeAuthorizationCode(input);
         return response;
       } catch (error) {
         log('Error exchanging authorization code: %O', error);
@@ -56,23 +59,23 @@ export const oidcRouter = router({
    * Get OAuth handoff information
    * GET /market/oidc/handoff?id=xxx
    */
-  getOAuthHandoff: oidcProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
-    log('getOAuthHandoff input: %O', input);
-
-    const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
-
-    try {
-      const handoff = await market.auth.getOAuthHandoff(input.id);
-      return handoff;
-    } catch (error) {
-      log('Error getting OAuth handoff: %O', error);
-      throw new TRPCError({
-        cause: error,
-        code: 'INTERNAL_SERVER_ERROR',
-        message: error instanceof Error ? error.message : 'Failed to get OAuth handoff',
-      });
-    }
-  }),
+  getOAuthHandoff: oidcProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('getOAuthHandoff input: %O', input);
+
+      try {
+        const handoff = await ctx.marketService.getOAuthHandoff(input.id);
+        return handoff;
+      } catch (error) {
+        log('Error getting OAuth handoff: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get OAuth handoff',
+        });
+      }
+    }),
 
   /**
    * Get user info from token or trusted client
@@ -83,37 +86,17 @@ export const oidcRouter = router({
     .mutation(async ({ input, ctx }) => {
       log('getUserInfo input: token=%s', input.token ? '[REDACTED]' : 'undefined');
 
-      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
-
       try {
         // If token is provided, use it
         if (input.token) {
-          const response = await market.auth.getUserInfo(input.token);
+          const response = await ctx.marketService.getUserInfo(input.token);
           return response;
         }
 
         // Otherwise, try to use trustedClientToken
         if (ctx.marketUserInfo) {
-          const trustedClientToken = generateTrustedClientToken(ctx.marketUserInfo);
-
-          if (trustedClientToken) {
-            const userInfoUrl = `${MARKET_BASE_URL}/lobehub-oidc/userinfo`;
-            const response = await fetch(userInfoUrl, {
-              headers: {
-                'Content-Type': 'application/json',
-                'x-lobe-trust-token': trustedClientToken,
-              },
-              method: 'GET',
-            });
-
-            if (!response.ok) {
-              throw new Error(
-                `Failed to fetch user info: ${response.status} ${response.statusText}`,
-              );
-            }
-
-            return await response.json();
-          }
+          const response = await ctx.marketService.getUserInfoWithTrustedClient();
+          return response;
         }
 
         throw new TRPCError({
@@ -143,15 +126,12 @@ export const oidcRouter = router({
         refreshToken: z.string(),
       }),
     )
-    .mutation(async ({ input }) => {
+    .mutation(async ({ input, ctx }) => {
       log('refreshToken input: %O', { ...input, refreshToken: '[REDACTED]' });
 
-      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
-
       try {
-        const response = await market.auth.exchangeOAuthToken({
-          clientId: input.clientId,
-          grantType: 'refresh_token',
+        const response = await ctx.marketService.refreshToken({
+          clientId: input.clientId || '',
           refreshToken: input.refreshToken,
         });
         return response;

package/src/server/routers/tools/market.ts

@@ -1,4 +1,4 @@
-import { type CodeInterpreterToolName, MarketSDK } from '@lobehub/market-sdk';
+import { type CodeInterpreterToolName } from '@lobehub/market-sdk';
 import { TRPCError } from '@trpc/server';
 import debug from 'debug';
 import { sha256 } from 'js-sha256';
@@ -8,10 +8,11 @@ import { type ToolCallContent } from '@/libs/mcp';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase, telemetry } from '@/libs/trpc/lambda/middleware';
 import { marketSDK, requireMarketAuth } from '@/libs/trpc/lambda/middleware/marketSDK';
-import { generateTrustedClientToken, isTrustedClientEnabled } from '@/libs/trusted-client';
+import { isTrustedClientEnabled } from '@/libs/trusted-client';
 import { FileS3 } from '@/server/modules/S3';
 import { DiscoverService } from '@/server/services/discover';
 import { FileService } from '@/server/services/file';
+import { MarketService } from '@/server/services/market';
 import {
   contentBlocksToString,
   processContentBlocks,
@@ -37,6 +38,10 @@ const marketToolProcedure = authedProcedure
           userInfo: ctx.marketUserInfo,
         }),
         fileService: new FileService(ctx.serverDB, ctx.userId),
+        marketService: new MarketService({
+          accessToken: ctx.marketAccessToken,
+          userInfo: ctx.marketUserInfo,
+        }),
         userModel,
       },
     });
@@ -79,7 +84,6 @@ const metaSchema = z
 
 // Schema for code interpreter tool call request
 const callCodeInterpreterToolSchema = z.object({
-  marketAccessToken: z.string().optional(),
   params: z.record(z.any()),
   toolName: z.string(),
   topicId: z.string(),
@@ -224,27 +228,17 @@ export const marketRouter = router({
   callCodeInterpreterTool: marketToolProcedure
     .input(callCodeInterpreterToolSchema)
     .mutation(async ({ input, ctx }) => {
-      const { toolName, params, userId, topicId, marketAccessToken } = input;
+      const { toolName, params, userId, topicId } = input;
 
       log('Calling cloud code interpreter tool: %s with params: %O', toolName, {
         params,
         topicId,
         userId,
       });
-      log('Market access token available: %s', marketAccessToken ? 'yes' : 'no');
-
-      // Generate trusted client token if user info is available
-      const trustedClientToken = ctx.marketUserInfo
-        ? generateTrustedClientToken(ctx.marketUserInfo)
-        : undefined;
 
       try {
-        // Initialize MarketSDK with market access token and trusted client token
-        const market = new MarketSDK({
-          accessToken: marketAccessToken,
-          baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
-          trustedClientToken,
-        });
+        // Use marketService from ctx
+        const market = ctx.marketService.market;
 
         // Call market-sdk's runBuildInTool
         const response = await market.plugins.runBuildInTool(
@@ -555,34 +549,8 @@ export const marketRouter = router({
         const uploadUrl = await s3.createPreSignedUrl(key);
         log('Generated upload URL for key: %s', key);
 
-        // Step 2: Generate trusted client token if user info is available
-        const trustedClientToken = ctx.marketUserInfo
-          ? generateTrustedClientToken(ctx.marketUserInfo)
-          : undefined;
-
-        // Only require user accessToken if trusted client is not available
-        let userAccessToken: string | undefined;
-        if (!trustedClientToken) {
-          const userState = await ctx.userModel.getUserState(async () => ({}));
-          userAccessToken = userState.settings?.market?.accessToken;
-
-          if (!userAccessToken) {
-            return {
-              error: { message: 'User access token not found. Please sign in to Market first.' },
-              filename,
-              success: false,
-            } as ExportAndUploadFileResult;
-          }
-        } else {
-          log('Using trusted client authentication for exportAndUploadFile');
-        }
-
-        // Initialize MarketSDK
-        const market = new MarketSDK({
-          accessToken: userAccessToken,
-          baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
-          trustedClientToken,
-        });
+        // Step 2: Use MarketService from ctx
+        const market = ctx.marketService.market;
 
         // Step 3: Call sandbox's exportFile tool with the upload URL
         const response = await market.plugins.runBuildInTool(

package/src/server/services/agentRuntime/AgentRuntimeService.test.ts

@@ -3,6 +3,13 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { AgentRuntimeService } from './AgentRuntimeService';
 import type { AgentExecutionParams, OperationCreationParams, StartExecutionParams } from './types';
 
+// Mock trusted client to avoid server-side env access
+vi.mock('@/libs/trusted-client', () => ({
+  generateTrustedClientToken: vi.fn().mockReturnValue(undefined),
+  getTrustedClientTokenForSession: vi.fn().mockResolvedValue(undefined),
+  isTrustedClientEnabled: vi.fn().mockReturnValue(false),
+}));
+
 // Mock database and models
 vi.mock('@/database/models/message', () => ({
   MessageModel: vi.fn().mockImplementation(() => ({

package/src/server/services/agentRuntime/AgentRuntimeService.ts

@@ -152,7 +152,7 @@ export class AgentRuntimeService {
 
     // Initialize ToolExecutionService with dependencies
     const pluginGatewayService = new PluginGatewayService();
-    const builtinToolsExecutor = new BuiltinToolsExecutor();
+    const builtinToolsExecutor = new BuiltinToolsExecutor(db, userId);
 
     this.toolExecutionService = new ToolExecutionService({
       builtinToolsExecutor,

package/src/server/services/aiAgent/__tests__/execAgent.threadId.test.ts

@@ -2,6 +2,13 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AiAgentService } from '../index';
 
+// Mock trusted client to avoid server-side env access
+vi.mock('@/libs/trusted-client', () => ({
+  generateTrustedClientToken: vi.fn().mockReturnValue(undefined),
+  getTrustedClientTokenForSession: vi.fn().mockResolvedValue(undefined),
+  isTrustedClientEnabled: vi.fn().mockReturnValue(false),
+}));
+
 // Mock MessageModel to capture create calls
 const mockMessageCreate = vi.fn();
 

package/src/server/services/aiAgent/__tests__/execGroupSubAgentTask.test.ts

@@ -3,6 +3,13 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AiAgentService } from '../index';
 
+// Mock trusted client to avoid server-side env access
+vi.mock('@/libs/trusted-client', () => ({
+  generateTrustedClientToken: vi.fn().mockReturnValue(undefined),
+  getTrustedClientTokenForSession: vi.fn().mockResolvedValue(undefined),
+  isTrustedClientEnabled: vi.fn().mockReturnValue(false),
+}));
+
 // Mock ThreadModel
 const mockThreadModel = {
   create: vi.fn(),