@lobehub/lobehub 2.0.0-next.327 → 2.0.0-next.329

package/src/libs/better-auth/sso/index.ts

@@ -1,6 +1,7 @@
 import type { GenericOAuthConfig } from 'better-auth/plugins';
 import type { SocialProviders } from 'better-auth/social-providers';
 
+import { appEnv } from '@/envs/app';
 import { authEnv } from '@/envs/auth';
 import { BUILTIN_BETTER_AUTH_PROVIDERS } from '@/libs/better-auth/constants';
 import { parseSSOProviders } from '@/libs/better-auth/utils/server';
@@ -106,7 +107,7 @@ export const initBetterAuthSSOProviders = () => {
     if (config) {
       // the generic oidc callback url is /api/auth/oauth2/callback/{providerId}
       // different from builtin providers' /api/auth/callback/{providerId}
-      config.redirectURI = `${authEnv.NEXT_PUBLIC_AUTH_URL || ''}/api/auth/callback/${definition.id}`;
+      config.redirectURI = `${appEnv.APP_URL}/api/auth/callback/${definition.id}`;
       genericOAuthProviders.push(config);
     }
   }

package/src/libs/better-auth/utils/config.ts

@@ -1,3 +1,4 @@
+import { appEnv } from '@/envs/app';
 import { authEnv } from '@/envs/auth';
 import { getRedisConfig } from '@/envs/redis';
 import { initializeRedis, isRedisEnabled } from '@/libs/redis';
@@ -48,8 +49,7 @@ export const getTrustedOrigins = (enabledSSOProviders: string[]) => {
   }
 
   const defaults = [
-    authEnv.NEXT_PUBLIC_AUTH_URL,
-    normalizeOrigin(process.env.APP_URL),
+    normalizeOrigin(appEnv.APP_URL),
     normalizeOrigin(process.env.VERCEL_BRANCH_URL),
     normalizeOrigin(process.env.VERCEL_URL),
     MOBILE_APP_SCHEME,

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

@@ -237,9 +237,8 @@ export function defineConfig() {
       // ref: https://authjs.dev/getting-started/session-management/protecting
       if (isProtected) {
         logNextAuth('Request a protected route, redirecting to sign-in page');
-        const authUrl = authEnv.NEXT_PUBLIC_AUTH_URL;
-        const callbackUrl = `${authUrl}${req.nextUrl.pathname}${req.nextUrl.search}`;
-        const nextLoginUrl = new URL('/next-auth/signin', authUrl);
+        const callbackUrl = `${appEnv.APP_URL}${req.nextUrl.pathname}${req.nextUrl.search}`;
+        const nextLoginUrl = new URL('/next-auth/signin', appEnv.APP_URL);
         nextLoginUrl.searchParams.set('callbackUrl', callbackUrl);
         const hl = req.nextUrl.searchParams.get('hl');
         if (hl) {
@@ -325,9 +324,8 @@ export function defineConfig() {
       // If request a protected route, redirect to sign-in page
       if (isProtected) {
         logBetterAuth('Request a protected route, redirecting to sign-in page');
-        const authUrl = authEnv.NEXT_PUBLIC_AUTH_URL;
-        const callbackUrl = `${authUrl}${req.nextUrl.pathname}${req.nextUrl.search}`;
-        const signInUrl = new URL('/signin', authUrl);
+        const callbackUrl = `${appEnv.APP_URL}${req.nextUrl.pathname}${req.nextUrl.search}`;
+        const signInUrl = new URL('/signin', appEnv.APP_URL);
         signInUrl.searchParams.set('callbackUrl', callbackUrl);
         const hl = req.nextUrl.searchParams.get('hl');
         if (hl) {

package/src/locales/default/chat.ts

@@ -230,6 +230,7 @@ export default {
   'noSelectedAgents': 'No members selected yet',
   'openInNewWindow': 'Open in New Window',
   'operation.execAgentRuntime': 'Preparing response',
+  'operation.execClientTask': 'Executing task',
   'operation.sendMessage': 'Sending message',
   'owner': 'Group owner',
   'pageCopilot.title': 'Page Agent',
@@ -354,13 +355,17 @@ export default {
   'tab.profile': 'Agent Profile',
   'tab.search': 'Search',
   'task.activity.calling': 'Calling Skill...',
+  'task.activity.clientExecuting': 'Executing locally...',
   'task.activity.generating': 'Generating response...',
   'task.activity.gotResult': 'Tool result received',
   'task.activity.toolCalling': 'Calling {{toolName}}...',
   'task.activity.toolResult': '{{toolName}} result received',
   'task.batchTasks': '{{count}} Batch Subtasks',
+  'task.instruction': 'Task Instruction',
+  'task.intermediateSteps': '{{count}} intermediate steps',
+  'task.metrics.duration': '(took {{duration}})',
   'task.metrics.stepsShort': 'steps',
-  'task.metrics.toolCallsShort': 'tool uses',
+  'task.metrics.toolCallsShort': 'skill uses',
   'task.status.cancelled': 'Task Cancelled',
   'task.status.failed': 'Task Failed',
   'task.status.initializing': 'Initializing task...',

package/src/locales/default/discover.ts

@@ -170,6 +170,8 @@ export default {
 
   'fork.viewAllForks': 'View all forks',
 
+  'groupAgents.tag': 'Group',
+
   'home.communityAgents': 'Community Agents',
 
   'home.featuredAssistants': 'Featured Agents',

package/src/server/routers/lambda/__tests__/integration/topic.integration.test.ts

@@ -285,6 +285,80 @@ describe('Topic Router Integration Tests', () => {
     });
   });
 
+  describe('batchDeleteByAgentId', () => {
+    it('should batch delete topics by agentId (new data)', async () => {
+      const caller = topicRouter.createCaller(createTestContext(userId));
+
+      // Create topics with agentId directly (new data structure)
+      const topicId1 = await caller.createTopic({
+        title: 'Agent Topic 1',
+        agentId: testAgentId,
+      });
+      const topicId2 = await caller.createTopic({
+        title: 'Agent Topic 2',
+        agentId: testAgentId,
+      });
+
+      // Batch delete by agentId
+      await caller.batchDeleteByAgentId({
+        agentId: testAgentId,
+      });
+
+      const remainingTopics = await serverDB.select().from(topics).where(eq(topics.userId, userId));
+
+      expect(remainingTopics).toHaveLength(0);
+    });
+
+    it('should batch delete topics by agentId (legacy sessionId data)', async () => {
+      const caller = topicRouter.createCaller(createTestContext(userId));
+
+      // Create topics with sessionId (legacy data structure)
+      await caller.createTopic({
+        title: 'Legacy Topic 1',
+        sessionId: testSessionId,
+      });
+      await caller.createTopic({
+        title: 'Legacy Topic 2',
+        sessionId: testSessionId,
+      });
+
+      // Batch delete by agentId should also delete legacy topics via sessionId mapping
+      await caller.batchDeleteByAgentId({
+        agentId: testAgentId,
+      });
+
+      const remainingTopics = await serverDB
+        .select()
+        .from(topics)
+        .where(eq(topics.sessionId, testSessionId));
+
+      expect(remainingTopics).toHaveLength(0);
+    });
+
+    it('should batch delete topics by agentId (mixed data)', async () => {
+      const caller = topicRouter.createCaller(createTestContext(userId));
+
+      // Create both new (agentId) and legacy (sessionId) topics
+      await caller.createTopic({
+        title: 'New Agent Topic',
+        agentId: testAgentId,
+      });
+      await caller.createTopic({
+        title: 'Legacy Session Topic',
+        sessionId: testSessionId,
+      });
+
+      // Batch delete by agentId should delete both
+      await caller.batchDeleteByAgentId({
+        agentId: testAgentId,
+      });
+
+      const remainingTopics = await serverDB.select().from(topics).where(eq(topics.userId, userId));
+
+      expect(remainingTopics).toHaveLength(0);
+    });
+  });
+
   describe('searchTopics', () => {
     it('should search topics using agentId', async () => {
       const caller = topicRouter.createCaller(createTestContext(userId));

package/src/server/routers/lambda/aiAgent.ts

@@ -1,5 +1,10 @@
 import { type AgentRuntimeContext } from '@lobechat/agent-runtime';
-import { type TaskCurrentActivity, type TaskStatusResult, ThreadStatus } from '@lobechat/types';
+import {
+  type TaskCurrentActivity,
+  type TaskStatusResult,
+  ThreadStatus,
+  ThreadType,
+} from '@lobechat/types';
 import { TRPCError } from '@trpc/server';
 import debug from 'debug';
 import pMap from 'p-map';
@@ -154,6 +159,49 @@ const ExecSubAgentTaskSchema = z.object({
   topicId: z.string(),
 });
 
+/**
+ * Schema for createClientTaskThread - create Thread for client-side task execution
+ * This is used when runInClient=true on desktop client
+ */
+const CreateClientTaskThreadSchema = z.object({
+  /** The Agent ID to execute the task */
+  agentId: z.string(),
+  /** The Group ID (optional, only for Group mode) */
+  groupId: z.string().optional(),
+  /** Initial user message content (task instruction) */
+  instruction: z.string(),
+  /** The parent message ID (task message) */
+  parentMessageId: z.string(),
+  /** Task title (shown in UI, used as thread title) */
+  title: z.string().optional(),
+  /** The Topic ID */
+  topicId: z.string(),
+});
+
+/**
+ * Schema for updateClientTaskThreadStatus - update Thread status after client-side execution
+ */
+const UpdateClientTaskThreadStatusSchema = z.object({
+  /** Completion reason */
+  completionReason: z.enum(['done', 'error', 'interrupted']),
+  /** Error message if failed */
+  error: z.string().optional(),
+  /** Thread metadata to update */
+  metadata: z
+    .object({
+      totalCost: z.number().optional(),
+      totalMessages: z.number().optional(),
+      totalSteps: z.number().optional(),
+      totalTokens: z.number().optional(),
+      totalToolCalls: z.number().optional(),
+    })
+    .optional(),
+  /** Result content (last assistant message) */
+  resultContent: z.string().optional(),
+  /** The Thread ID */
+  threadId: z.string(),
+});
+
 /**
  * Schema for interruptTask - interrupt a running task
  */
@@ -184,6 +232,100 @@ const aiAgentProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
 });
 
 export const aiAgentRouter = router({
+  /**
+   * Create Thread for client-side task execution
+   *
+   * This endpoint is called by desktop client when runInClient=true.
+   * It creates the Thread but does NOT execute the task - execution happens on client side.
+   */
+  createClientTaskThread: aiAgentProcedure
+    .input(CreateClientTaskThreadSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { agentId, groupId, instruction, parentMessageId, title, topicId } = input;
+
+      log('createClientTaskThread: agentId=%s, groupId=%s', agentId, groupId);
+
+      try {
+        // 1. Create Thread for isolated task execution
+        const startedAt = new Date().toISOString();
+        const thread = await ctx.threadModel.create({
+          agentId,
+          groupId,
+          metadata: { clientMode: true, startedAt },
+          sourceMessageId: parentMessageId,
+          status: ThreadStatus.Processing,
+          title,
+          topicId,
+          type: ThreadType.Isolation,
+        });
+
+        if (!thread) {
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: 'Failed to create thread for task execution',
+          });
+        }
+
+        log('createClientTaskThread: created thread %s', thread.id);
+
+        // 2. Create initial user message (persisted to database)
+        const userMessage = await ctx.messageModel.create({
+          agentId,
+          content: instruction,
+          parentId: parentMessageId,
+          role: 'user',
+          threadId: thread.id,
+          topicId,
+        });
+
+        log('createClientTaskThread: created user message %s', userMessage.id);
+
+        // 3. Query thread messages and main chat messages in parallel
+        const [threadMessages, messages] = await Promise.all([
+          // Thread messages (messages within this thread)
+          ctx.messageModel.query({
+            agentId,
+            threadId: thread.id,
+            topicId,
+          }),
+          // Main chat messages (messages without threadId, includes updated taskDetail)
+          ctx.messageModel.query({
+            agentId,
+            topicId,
+            // No threadId - matchThread will filter for threadId IS NULL (main chat)
+          }),
+        ]);
+
+        log(
+          'createClientTaskThread: queried %d thread messages, %d main messages',
+          threadMessages.length,
+          messages.length,
+        );
+
+        // 4. Return Thread, userMessageId, threadMessages and messages
+        return {
+          messages,
+          startedAt,
+          success: true,
+          threadId: thread.id,
+          threadMessages,
+          userMessageId: userMessage.id,
+        };
+      } catch (error: any) {
+        log('createClientTaskThread failed: %O', error);
+
+        if (error instanceof TRPCError) {
+          throw error;
+        }
+
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to create client task thread: ${error.message}`,
+        });
+      }
+    }),
+
   createOperation: aiAgentProcedure
     .input(CreateAgentOperationSchema)
     .mutation(async ({ input, ctx }) => {
@@ -846,4 +988,100 @@ export const aiAgentRouter = router({
       timestamp: new Date().toISOString(),
     };
   }),
+
+  /**
+   * Update Thread status after client-side task execution completes
+   *
+   * This endpoint is called by desktop client after task execution finishes.
+   * It updates the Thread status and metadata similar to server-side completion.
+   */
+  updateClientTaskThreadStatus: aiAgentProcedure
+    .input(UpdateClientTaskThreadStatusSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { threadId, completionReason, error, resultContent, metadata } = input;
+
+      log('updateClientTaskThreadStatus: threadId=%s, reason=%s', threadId, completionReason);
+
+      try {
+        // Find thread
+        const thread = await ctx.threadModel.findById(threadId);
+        if (!thread) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Thread not found',
+          });
+        }
+
+        const completedAt = new Date().toISOString();
+        const startedAt = thread.metadata?.startedAt;
+        const duration = startedAt ? Date.now() - new Date(startedAt).getTime() : undefined;
+
+        // Determine thread status based on completion reason
+        let status: ThreadStatus;
+        switch (completionReason) {
+          case 'done': {
+            status = ThreadStatus.Completed;
+            break;
+          }
+          case 'error': {
+            status = ThreadStatus.Failed;
+            break;
+          }
+          case 'interrupted': {
+            status = ThreadStatus.Cancel;
+            break;
+          }
+          default: {
+            status = ThreadStatus.Completed;
+          }
+        }
+
+        // Update Thread metadata and status
+        await ctx.threadModel.update(threadId, {
+          metadata: {
+            ...thread.metadata,
+            completedAt,
+            duration,
+            error: error || undefined,
+            totalCost: metadata?.totalCost,
+            totalMessages: metadata?.totalMessages,
+            totalSteps: metadata?.totalSteps,
+            totalTokens: metadata?.totalTokens,
+            totalToolCalls: metadata?.totalToolCalls,
+          },
+          status,
+        });
+
+        // Update task message (sourceMessageId) with result content if provided
+        if (resultContent && thread.sourceMessageId) {
+          await ctx.messageModel.update(thread.sourceMessageId, {
+            content: resultContent,
+          });
+          log(
+            'updateClientTaskThreadStatus: updated task message %s with result',
+            thread.sourceMessageId,
+          );
+        }
+
+        log('updateClientTaskThreadStatus: thread %s completed with status %s', threadId, status);
+
+        return {
+          status,
+          success: true,
+          threadId,
+        };
+      } catch (error: any) {
+        log('updateClientTaskThreadStatus failed: %O', error);
+
+        if (error instanceof TRPCError) {
+          throw error;
+        }
+
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to update client task thread status: ${error.message}`,
+        });
+      }
+    }),
 });

package/src/server/routers/lambda/thread.ts

@@ -21,6 +21,7 @@ const threadProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
 export const threadRouter = router({
   createThread: threadProcedure.input(createThreadSchema).mutation(async ({ input, ctx }) => {
     const thread = await ctx.threadModel.create({
+      metadata: input.metadata,
       parentThreadId: input.parentThreadId,
       sourceMessageId: input.sourceMessageId,
       title: input.title,
@@ -38,6 +39,7 @@ export const threadRouter = router({
     )
     .mutation(async ({ input, ctx }) => {
       const thread = await ctx.threadModel.create({
+        metadata: input.metadata,
         parentThreadId: input.parentThreadId,
         sourceMessageId: input.sourceMessageId,
         title: input.message.content.slice(0, 20),

package/src/server/routers/lambda/topic.ts

@@ -76,6 +76,12 @@ export const topicRouter = router({
       return ctx.topicModel.batchDelete(input.ids);
     }),
 
+  batchDeleteByAgentId: topicProcedure
+    .input(z.object({ agentId: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicModel.batchDeleteByAgentId(input.agentId);
+    }),
+
   batchDeleteBySessionId: topicProcedure
     .input(
       z.object({

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

@@ -1,3 +1,6 @@
+/**
+ * @vitest-environment node
+ */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AgentRuntimeService } from './AgentRuntimeService';
@@ -166,7 +169,7 @@ describe('AgentRuntimeService', () => {
     it('should initialize with default base URL', () => {
       delete process.env.AGENT_RUNTIME_BASE_URL;
       const newService = new AgentRuntimeService(mockDb, mockUserId);
-      expect((newService as any).baseURL).toBe('http://localhost:3010/api/agent');
+      expect((newService as any).baseURL).toBe('http://localhost:3210/api/agent');
     });
 
     it('should initialize with custom base URL from environment', () => {

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

@@ -10,6 +10,7 @@ import urlJoin from 'url-join';
 
 import { MessageModel } from '@/database/models/message';
 import { type LobeChatDatabase } from '@/database/type';
+import { appEnv } from '@/envs/app';
 import {
   AgentRuntimeCoordinator,
   type AgentRuntimeCoordinatorOptions,
@@ -126,7 +127,7 @@ export class AgentRuntimeService {
   private stepCallbacks: Map<string, StepLifecycleCallbacks> = new Map();
   private get baseURL() {
     const baseUrl =
-      process.env.AGENT_RUNTIME_BASE_URL || process.env.APP_URL || 'http://localhost:3010';
+      process.env.AGENT_RUNTIME_BASE_URL || appEnv.APP_URL || 'http://localhost:3010';
 
     return urlJoin(baseUrl, '/api/agent');
   }

package/src/server/services/message/__tests__/index.test.ts

@@ -293,6 +293,7 @@ describe('MessageService', () => {
           current: 0,
           groupId: undefined,
           pageSize: 9999,
+          threadId: undefined,
           topicId: undefined,
         },
         expect.objectContaining({
@@ -327,6 +328,42 @@ describe('MessageService', () => {
           current: 0,
           groupId: 'group-1',
           pageSize: 9999,
+          threadId: undefined,
+          topicId: 'topic-1',
+        },
+        expect.objectContaining({
+          postProcessUrl: expect.any(Function),
+        }),
+      );
+      expect(result.id).toBe('msg-1');
+      expect(result.messages).toEqual(mockMessages);
+    });
+
+    it('should create message with threadId and query thread messages', async () => {
+      const params = {
+        agentId: 'agent-1',
+        content: 'Hello in thread',
+        groupId: 'group-1',
+        role: 'user' as const,
+        threadId: 'thread-1',
+        topicId: 'topic-1',
+      };
+      const createdMessage = { id: 'msg-1', ...params };
+      const mockMessages = [createdMessage];
+
+      vi.mocked(mockMessageModel.create).mockResolvedValue(createdMessage as any);
+      vi.mocked(mockMessageModel.query).mockResolvedValue(mockMessages as any);
+
+      const result = await messageService.createMessage(params as any);
+
+      expect(mockMessageModel.create).toHaveBeenCalledWith(params);
+      expect(mockMessageModel.query).toHaveBeenCalledWith(
+        {
+          agentId: 'agent-1',
+          current: 0,
+          groupId: 'group-1',
+          pageSize: 9999,
+          threadId: 'thread-1',
           topicId: 'topic-1',
         },
         expect.objectContaining({

package/src/server/services/message/index.ts

@@ -1,5 +1,9 @@
 import { type LobeChatDatabase } from '@lobechat/database';
-import { type CreateMessageParams, type UIChatMessage, type UpdateMessageParams } from '@lobechat/types';
+import {
+  type CreateMessageParams,
+  type UIChatMessage,
+  type UpdateMessageParams,
+} from '@lobechat/types';
 
 import { MessageModel } from '@/database/models/message';
 
@@ -95,6 +99,7 @@ export class MessageService {
         current: 0,
         groupId: params.groupId,
         pageSize: 9999,
+        threadId: params.threadId,
         topicId: params.topicId,
       },
       {

package/src/services/aiAgent.ts

@@ -40,6 +40,38 @@ export interface InterruptTaskParams {
   threadId?: string;
 }
 
+/**
+ * Parameters for createClientTaskThread
+ * Creates a Thread for client-side task execution (desktop only)
+ */
+export interface CreateClientTaskThreadParams {
+  agentId: string;
+  groupId?: string;
+  /** Initial user message content (task instruction) */
+  instruction: string;
+  parentMessageId: string;
+  title?: string;
+  topicId: string;
+}
+
+/**
+ * Parameters for updateClientTaskThreadStatus
+ * Updates Thread status after client-side execution completes
+ */
+export interface UpdateClientTaskThreadStatusParams {
+  completionReason: 'done' | 'error' | 'interrupted';
+  error?: string;
+  metadata?: {
+    totalCost?: number;
+    totalMessages?: number;
+    totalSteps?: number;
+    totalTokens?: number;
+    totalToolCalls?: number;
+  };
+  resultContent?: string;
+  threadId: string;
+}
+
 class AiAgentService {
   /**
    * Execute a single Agent task
@@ -72,6 +104,25 @@ class AiAgentService {
   async interruptTask(params: InterruptTaskParams) {
     return await lambdaClient.aiAgent.interruptTask.mutate(params);
   }
+
+  /**
+   * Create Thread for client-side task execution (desktop only)
+   *
+   * This method is called when runInClient=true on desktop client.
+   * It creates the Thread but does NOT execute the task - execution happens locally.
+   */
+  async createClientTaskThread(params: CreateClientTaskThreadParams) {
+    return await lambdaClient.aiAgent.createClientTaskThread.mutate(params);
+  }
+
+  /**
+   * Update Thread status after client-side task execution completes
+   *
+   * This method is called by desktop client after task execution finishes.
+   */
+  async updateClientTaskThreadStatus(params: UpdateClientTaskThreadStatusParams) {
+    return await lambdaClient.aiAgent.updateClientTaskThreadStatus.mutate(params);
+  }
 }
 
 export const aiAgentService = new AiAgentService();

package/src/services/topic/index.ts

@@ -109,6 +109,10 @@ export class TopicService {
     return lambdaClient.topic.batchDeleteBySessionId.mutate({ id: this.toDbSessionId(sessionId) });
   };
 
+  removeTopicsByAgentId = (agentId: string) => {
+    return lambdaClient.topic.batchDeleteByAgentId.mutate({ agentId });
+  };
+
   batchRemoveTopics = (topics: string[]) => {
     return lambdaClient.topic.batchDelete.mutate({ ids: topics });
   };