@lobehub/lobehub 2.0.0-next.32 → 2.0.0-next.33

package/packages/conversation-flow/src/types/shared.ts

@@ -0,0 +1,63 @@
+import type { UIChatMessage } from '@lobechat/types';
+
+import type { ContextNode } from './contextTree';
+import type { FlatMessage } from './flatMessageList';
+
+/**
+ * Shared Types
+ *
+ * Common types used across the conversation flow engine.
+ */
+
+/**
+ * Re-export UIChatMessage as Message for convenience
+ */
+export type Message = UIChatMessage;
+
+/**
+ * Message group metadata from database
+ * Used for multi-model parallel conversations and manual grouping
+ */
+export interface MessageGroupMetadata {
+  description?: string;
+  id: string;
+  /** Presentation mode: compare, summary, or manual */
+  mode?: 'compare' | 'summary' | 'manual';
+  /** Parent message that triggered this group */
+  parentMessageId?: string;
+  title?: string;
+}
+
+/**
+ * Internal structure node used during tree building
+ */
+export interface IdNode {
+  children: IdNode[];
+  id: string;
+}
+
+/**
+ * Result of the parse function
+ */
+export interface ParseResult {
+  /** Semantic tree structure for navigation and context understanding */
+  contextTree: ContextNode[];
+  /** Flattened list optimized for virtual list rendering */
+  flatList: FlatMessage[];
+  /** Map for O(1) message access */
+  messageMap: Record<string, Message>;
+}
+
+/**
+ * Internal helper maps used during parsing
+ */
+export interface HelperMaps {
+  /** Maps parent ID to array of child IDs */
+  childrenMap: Map<string | null, string[]>;
+  /** Maps message group ID to its metadata */
+  messageGroupMap: Map<string, MessageGroupMetadata>;
+  /** Maps message ID to message */
+  messageMap: Map<string, Message>;
+  /** Maps thread ID to all messages in that thread */
+  threadMap: Map<string, Message[]>;
+}

package/packages/conversation-flow/src/types.ts

@@ -0,0 +1,36 @@
+/**
+ * Type Index
+ *
+ * Centralized exports for all conversation flow types.
+ * Types are organized into three categories:
+ *
+ * 1. Context Tree (types/contextTree.ts) - Tree structure for navigation
+ * 2. Flat Message List (types/flatMessageList.ts) - Optimized for rendering
+ * 3. Shared (types/shared.ts) - Common types used across modules
+ */
+
+// Context Tree Types
+export type {
+  AssistantGroupNode,
+  BranchNode,
+  CompareNode,
+  ContextNode,
+  MessageNode,
+} from './types/contextTree';
+
+// Flat Message List Types
+export type {
+  BranchMetadata,
+  FlatMessage,
+  FlatMessageExtra,
+  FlatMessageRole,
+} from './types/flatMessageList';
+
+// Shared Types
+export type {
+  HelperMaps,
+  IdNode,
+  Message,
+  MessageGroupMetadata,
+  ParseResult,
+} from './types/shared';

package/packages/conversation-flow/vitest.config.mts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+    },
+    environment: 'happy-dom',
+  },
+});

package/packages/types/src/message/common/metadata.ts

@@ -103,4 +103,8 @@ export interface ModelPerformance {
   latency?: number;
 }
 
-export interface MessageMetadata extends ModelUsage, ModelPerformance {}
+export interface MessageMetadata extends ModelUsage, ModelPerformance {
+  activeBranchIndex?: number;
+  activeColumn?: boolean;
+  compare?: boolean;
+}

package/src/app/[variants]/(main)/chat/@session/features/SessionListContent/List/Item/index.tsx

@@ -4,9 +4,8 @@ import { Flexbox } from 'react-layout-kit';
 import { shallow } from 'zustand/shallow';
 
 import { DEFAULT_AVATAR } from '@/const/meta';
+import { INBOX_SESSION_ID } from '@/const/session';
 import { isDesktop } from '@/const/version';
-import { useAgentStore } from '@/store/agent';
-import { agentSelectors } from '@/store/agent/selectors';
 import { useChatStore } from '@/store/chat';
 import { messageStateSelectors } from '@/store/chat/selectors';
 import { useGlobalStore } from '@/store/global';
@@ -28,7 +27,6 @@ interface SessionItemProps {
 const SessionItem = memo<SessionItemProps>(({ id }) => {
   const [open, setOpen] = useState(false);
   const [createGroupModalOpen, setCreateGroupModalOpen] = useState(false);
-  const [defaultModel] = useAgentStore((s) => [agentSelectors.inboxAgentModel(s)]);
 
   const openSessionInNewWindow = useGlobalStore((s) => s.openSessionInNewWindow);
 
@@ -55,7 +53,8 @@ const SessionItem = memo<SessionItemProps>(({ id }) => {
       ];
     });
 
-  const showModel = sessionType === 'agent' && model && model !== defaultModel;
+  // Only hide the model tag for the inbox session itself (随便聊聊)
+  const showModel = sessionType === 'agent' && model && id !== INBOX_SESSION_ID;
 
   const handleDoubleClick = () => {
     if (isDesktop) {

package/src/envs/__tests__/app.test.ts

@@ -1,18 +1,10 @@
 // @vitest-environment node
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { getAppConfig } from '../app';
-
-// Stub the global process object to safely mock environment variables
-vi.stubGlobal('process', {
-  ...process, // Preserve the original process object
-  env: { ...process.env }, // Clone the environment variables object for modification
-});
-
 describe('getServerConfig', () => {
   beforeEach(() => {
-    // Reset environment variables before each test case
-    vi.restoreAllMocks();
+    // Reset modules to clear the cached config
+    vi.resetModules();
   });
 
   // it('correctly handles values for OPENAI_FUNCTION_REGIONS', () => {
@@ -22,7 +14,8 @@ describe('getServerConfig', () => {
   // });
 
   describe('index url', () => {
-    it('should return default URLs when no environment variables are set', () => {
+    it('should return default URLs when no environment variables are set', async () => {
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe(
         'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public',
@@ -32,18 +25,20 @@ describe('getServerConfig', () => {
       );
     });
 
-    it('should return custom URLs when environment variables are set', () => {
+    it('should return custom URLs when environment variables are set', async () => {
       process.env.AGENTS_INDEX_URL = 'https://custom-agents-url.com';
       process.env.PLUGINS_INDEX_URL = 'https://custom-plugins-url.com';
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe('https://custom-agents-url.com');
       expect(config.PLUGINS_INDEX_URL).toBe('https://custom-plugins-url.com');
     });
 
-    it('should return default URLs when environment variables are empty string', () => {
+    it('should return default URLs when environment variables are empty string', async () => {
       process.env.AGENTS_INDEX_URL = '';
       process.env.PLUGINS_INDEX_URL = '';
 
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe(
         'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public',
@@ -53,4 +48,43 @@ describe('getServerConfig', () => {
       );
     });
   });
+
+  describe('INTERNAL_APP_URL', () => {
+    it('should default to APP_URL when INTERNAL_APP_URL is not set', async () => {
+      process.env.APP_URL = 'https://example.com';
+      delete process.env.INTERNAL_APP_URL;
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('https://example.com');
+    });
+
+    it('should use INTERNAL_APP_URL when explicitly set', async () => {
+      process.env.APP_URL = 'https://public.example.com';
+      process.env.INTERNAL_APP_URL = 'http://localhost:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('http://localhost:3210');
+    });
+
+    it('should use INTERNAL_APP_URL over APP_URL when both are set', async () => {
+      process.env.APP_URL = 'https://public.example.com';
+      process.env.INTERNAL_APP_URL = 'http://internal-service:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.APP_URL).toBe('https://public.example.com');
+      expect(config.INTERNAL_APP_URL).toBe('http://internal-service:3210');
+    });
+
+    it('should handle localhost INTERNAL_APP_URL for bypassing CDN', async () => {
+      process.env.APP_URL = 'https://cloudflare-proxied.com';
+      process.env.INTERNAL_APP_URL = 'http://127.0.0.1:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('http://127.0.0.1:3210');
+    });
+  });
 });

package/src/envs/app.ts

@@ -20,6 +20,10 @@ const APP_URL = process.env.APP_URL
     ? vercelUrl
     : 'http://localhost:3010';
 
+// INTERNAL_APP_URL is used for server-to-server calls to bypass CDN/proxy
+// Falls back to APP_URL if not set
+const INTERNAL_APP_URL = process.env.INTERNAL_APP_URL || APP_URL;
+
 const ASSISTANT_INDEX_URL = 'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public';
 
 const PLUGINS_INDEX_URL = 'https://registry.npmmirror.com/@lobehub/plugins-index/v1/files/public';
@@ -43,6 +47,7 @@ export const getAppConfig = () => {
       PLUGIN_SETTINGS: z.string().optional(),
 
       APP_URL: z.string().optional(),
+      INTERNAL_APP_URL: z.string().optional(),
       VERCEL_EDGE_CONFIG: z.string().optional(),
       MIDDLEWARE_REWRITE_THROUGH_LOCAL: z.boolean().optional(),
       ENABLE_AUTH_PROTECTION: z.boolean().optional(),
@@ -77,6 +82,7 @@ export const getAppConfig = () => {
       VERCEL_EDGE_CONFIG: process.env.VERCEL_EDGE_CONFIG,
 
       APP_URL,
+      INTERNAL_APP_URL,
       MIDDLEWARE_REWRITE_THROUGH_LOCAL: process.env.MIDDLEWARE_REWRITE_THROUGH_LOCAL === '1',
       ENABLE_AUTH_PROTECTION: process.env.ENABLE_AUTH_PROTECTION === '1',
 

package/src/server/routers/async/__tests__/caller.test.ts

@@ -0,0 +1,333 @@
+// @vitest-environment node
+// Import the module under test after mocks are set up
+import { createTRPCClient, httpLink } from '@trpc/client';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+
+import { createAsyncServerClient } from '../caller';
+
+// Create mockable appEnv - use object property to allow mutation
+const mockAppEnv: { APP_URL?: string; INTERNAL_APP_URL?: string | null | undefined } = {
+  APP_URL: 'https://public.example.com',
+  INTERNAL_APP_URL: 'http://localhost:3210',
+};
+
+// Mock dependencies before importing the module under test
+vi.mock('@trpc/client', () => ({
+  createTRPCClient: vi.fn(),
+  httpLink: vi.fn((options) => options),
+}));
+
+vi.mock('@/envs/app', () => ({
+  get appEnv() {
+    return mockAppEnv;
+  },
+}));
+
+vi.mock('@/server/modules/KeyVaultsEncrypt', () => ({
+  KeyVaultsGateKeeper: {
+    initWithEnvKey: vi.fn(),
+  },
+}));
+
+vi.mock('@/config/db', () => ({
+  serverDBEnv: {
+    KEY_VAULTS_SECRET: 'test-secret-key',
+  },
+}));
+
+vi.mock('@/const/version', () => ({
+  isDesktop: false,
+}));
+
+describe('createAsyncServerClient - INTERNAL_APP_URL Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    const mockEncrypt = vi.fn().mockResolvedValue('encrypted-payload-data');
+    vi.mocked(KeyVaultsGateKeeper.initWithEnvKey).mockResolvedValue({
+      encrypt: mockEncrypt,
+    } as any);
+    vi.mocked(createTRPCClient).mockReturnValue({ _mockClient: true } as any);
+
+    // Reset to default values by mutating the object
+    mockAppEnv.APP_URL = 'https://public.example.com';
+    mockAppEnv.INTERNAL_APP_URL = 'http://localhost:3210';
+  });
+
+  describe('URL selection logic', () => {
+    it('should use INTERNAL_APP_URL when both APP_URL and INTERNAL_APP_URL are set', async () => {
+      mockAppEnv.APP_URL = 'https://public.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'http://localhost:3210';
+
+      await createAsyncServerClient('user-123', { apiKey: 'test-key' });
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('http://localhost:3210/trpc/async');
+      expect(httpLinkOptions.url).not.toContain('public.example.com');
+    });
+
+    it('should fall back to APP_URL when INTERNAL_APP_URL is not set in env', async () => {
+      // Simulating the result of getInternalAppUrl() when INTERNAL_APP_URL is not in env
+      // In this case, appEnv.INTERNAL_APP_URL would equal appEnv.APP_URL
+      mockAppEnv.APP_URL = 'https://fallback.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'https://fallback.example.com'; // getInternalAppUrl() returns APP_URL
+
+      await createAsyncServerClient('user-456', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('https://fallback.example.com/trpc/async');
+    });
+
+    it('should use localhost to bypass CDN proxy', async () => {
+      mockAppEnv.APP_URL = 'https://cdn-proxied.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'http://127.0.0.1:3210';
+
+      await createAsyncServerClient('user-789', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('http://127.0.0.1:3210/trpc/async');
+      expect(httpLinkOptions.url).not.toContain('cdn-proxied');
+    });
+
+    it('should use internal service name in Docker network', async () => {
+      mockAppEnv.APP_URL = 'https://public.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'http://lobe-service:3210';
+
+      await createAsyncServerClient('user-docker', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('http://lobe-service:3210/trpc/async');
+    });
+
+    it('should handle INTERNAL_APP_URL with trailing slash', async () => {
+      mockAppEnv.INTERNAL_APP_URL = 'http://localhost:3210/';
+
+      await createAsyncServerClient('user-trailing', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // urlJoin should normalize the trailing slash
+      expect(httpLinkOptions.url).toBe('http://localhost:3210/trpc/async');
+    });
+
+    it('should handle INTERNAL_APP_URL without trailing slash', async () => {
+      mockAppEnv.INTERNAL_APP_URL = 'https://example.com';
+
+      await createAsyncServerClient('user-no-trailing', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('https://example.com/trpc/async');
+    });
+  });
+
+  describe('authentication and headers', () => {
+    it('should include Authorization header with KEY_VAULTS_SECRET', async () => {
+      await createAsyncServerClient('user-auth', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.headers).toHaveProperty('Authorization');
+      expect(httpLinkOptions.headers.Authorization).toBe('Bearer test-secret-key');
+    });
+
+    it('should encrypt and include user payload in x-lobe-chat-auth header', async () => {
+      const testPayload = { apiKey: 'test-api-key-value', provider: 'openai' };
+      const mockEncrypt = vi.fn().mockResolvedValue('test-encrypted-auth-data');
+      vi.mocked(KeyVaultsGateKeeper.initWithEnvKey).mockResolvedValueOnce({
+        encrypt: mockEncrypt,
+      } as any);
+
+      await createAsyncServerClient('user-encrypt', testPayload);
+
+      expect(KeyVaultsGateKeeper.initWithEnvKey).toHaveBeenCalled();
+      expect(mockEncrypt).toHaveBeenCalledWith(
+        JSON.stringify({ payload: testPayload, userId: 'user-encrypt' }),
+      );
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // The header name is from LOBE_CHAT_AUTH_HEADER constant
+      expect(httpLinkOptions.headers).toHaveProperty('Authorization');
+      // The X-lobe-chat-auth header should be present
+      expect(Object.keys(httpLinkOptions.headers)).toContain('X-lobe-chat-auth');
+      expect(httpLinkOptions.headers['X-lobe-chat-auth']).toBe('test-encrypted-auth-data');
+    });
+
+    it('should include Vercel bypass secret when available', async () => {
+      const originalEnv = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+      process.env.VERCEL_AUTOMATION_BYPASS_SECRET = 'test-bypass-value';
+
+      await createAsyncServerClient('user-vercel', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.headers).toHaveProperty('x-vercel-protection-bypass');
+      expect(httpLinkOptions.headers['x-vercel-protection-bypass']).toBe('test-bypass-value');
+
+      // Restore original env
+      if (originalEnv) {
+        process.env.VERCEL_AUTOMATION_BYPASS_SECRET = originalEnv;
+      } else {
+        delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+      }
+    });
+
+    it('should not include Vercel bypass secret when not available', async () => {
+      delete process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+
+      await createAsyncServerClient('user-no-vercel', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.headers).not.toHaveProperty('x-vercel-protection-bypass');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle encryption failure gracefully', async () => {
+      const mockEncrypt = vi.fn().mockRejectedValueOnce(new Error('Encryption failed'));
+      vi.mocked(KeyVaultsGateKeeper.initWithEnvKey).mockResolvedValueOnce({
+        encrypt: mockEncrypt,
+      } as any);
+
+      await expect(createAsyncServerClient('user-enc-fail', {})).rejects.toThrow(
+        'Encryption failed',
+      );
+
+      expect(KeyVaultsGateKeeper.initWithEnvKey).toHaveBeenCalled();
+    });
+
+    it('should handle missing INTERNAL_APP_URL by using APP_URL', async () => {
+      // When INTERNAL_APP_URL is not set in env, getInternalAppUrl() returns APP_URL
+      mockAppEnv.APP_URL = 'https://only-app-url.com';
+      mockAppEnv.INTERNAL_APP_URL = 'https://only-app-url.com'; // Result of fallback
+
+      await createAsyncServerClient('user-null', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // Should use APP_URL when INTERNAL_APP_URL is not set in environment
+      expect(httpLinkOptions.url).toContain('only-app-url.com');
+    });
+
+    it('should handle empty string INTERNAL_APP_URL', async () => {
+      mockAppEnv.APP_URL = 'https://fallback-from-empty.com';
+      mockAppEnv.INTERNAL_APP_URL = '';
+
+      await createAsyncServerClient('user-empty', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // Empty string is falsy, so urlJoin will use it but result may vary
+      expect(httpLinkOptions.url).toBeDefined();
+      expect(httpLinkOptions.url).toContain('trpc/async');
+    });
+
+    it('should handle malformed URL gracefully', async () => {
+      mockAppEnv.INTERNAL_APP_URL = 'not-a-valid-url';
+
+      await createAsyncServerClient('user-malformed', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // urlJoin will still create a result, even if base is malformed
+      expect(httpLinkOptions.url).toBeDefined();
+      expect(httpLinkOptions.url).toContain('trpc/async');
+    });
+  });
+
+  describe('TRPC client configuration', () => {
+    it('should configure httpLink with proper options', async () => {
+      await createAsyncServerClient('user-config', {});
+
+      expect(httpLink).toHaveBeenCalled();
+      const httpLinkOptions = vi.mocked(httpLink).mock.calls[0][0];
+
+      expect(httpLinkOptions).toHaveProperty('url');
+      expect(httpLinkOptions).toHaveProperty('headers');
+      expect(httpLinkOptions).toHaveProperty('transformer');
+    });
+
+    it('should pass httpLink result to createTRPCClient', async () => {
+      await createAsyncServerClient('user-link', {});
+
+      expect(createTRPCClient).toHaveBeenCalledWith({
+        links: expect.arrayContaining([
+          expect.objectContaining({
+            url: expect.any(String),
+            headers: expect.any(Object),
+          }),
+        ]),
+      });
+    });
+
+    it('should return the created TRPC client', async () => {
+      const client = await createAsyncServerClient('user-return', {});
+
+      expect(client).toBeDefined();
+      expect(client).toHaveProperty('_mockClient');
+      expect((client as any)._mockClient).toBe(true);
+    });
+  });
+
+  describe('real-world scenarios', () => {
+    it('should handle production deployment behind Cloudflare', async () => {
+      mockAppEnv.APP_URL = 'https://lobechat.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'http://localhost:3210';
+
+      await createAsyncServerClient('prod-user', { apiKey: 'test-key' });
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // Should use localhost to avoid CDN timeout
+      expect(httpLinkOptions.url).toBe('http://localhost:3210/trpc/async');
+    });
+
+    it('should handle Docker Compose deployment with service names', async () => {
+      mockAppEnv.APP_URL = 'https://public.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'http://lobe-chat-database:3210';
+
+      await createAsyncServerClient('docker-user', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      expect(httpLinkOptions.url).toBe('http://lobe-chat-database:3210/trpc/async');
+    });
+
+    it('should handle deployment without CDN (INTERNAL_APP_URL not set)', async () => {
+      // When not using CDN, INTERNAL_APP_URL is not set, so it falls back to APP_URL
+      mockAppEnv.APP_URL = 'https://direct-access.example.com';
+      mockAppEnv.INTERNAL_APP_URL = 'https://direct-access.example.com'; // Result of getInternalAppUrl() fallback
+
+      await createAsyncServerClient('direct-user', {});
+
+      const config = vi.mocked(createTRPCClient).mock.calls[0][0];
+      const httpLinkOptions = config.links[0] as any;
+
+      // Should fallback to APP_URL
+      expect(httpLinkOptions.url).toBe('https://direct-access.example.com/trpc/async');
+    });
+  });
+});

package/src/server/routers/async/caller.ts

@@ -30,7 +30,8 @@ export const createAsyncServerClient = async (userId: string, payload: ClientSec
       httpLink({
         headers,
         transformer: superjson,
-        url: urlJoin(appEnv.APP_URL!, '/trpc/async'),
+        // Use INTERNAL_APP_URL for server-to-server calls to bypass CDN/proxy
+        url: urlJoin(appEnv.INTERNAL_APP_URL!, '/trpc/async'),
       }),
     ],
   });