@lobehub/lobehub 2.0.0-next.35 → 2.0.0-next.37

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+## [Version 2.0.0-next.37](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.36...v2.0.0-next.37)
+
+<sup>Released on **2025-11-07**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Don't include runtimeProvider in JWT for non-image operations.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Don't include runtimeProvider in JWT for non-image operations, closes [#9959](https://github.com/lobehub/lobe-chat/issues/9959) [#9569](https://github.com/lobehub/lobe-chat/issues/9569) ([b8f25de](https://github.com/lobehub/lobe-chat/commit/b8f25de))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.36](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.35...v2.0.0-next.36)
+
+<sup>Released on **2025-11-07**</sup>
+
+#### ✨ Features
+
+- **misc**: Refactor to use agent runtime as the generation core and support branch mode.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Refactor to use agent runtime as the generation core and support branch mode, closes [#10080](https://github.com/lobehub/lobe-chat/issues/10080) ([b95e741](https://github.com/lobehub/lobe-chat/commit/b95e741))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.35](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.34...v2.0.0-next.35)
 
 <sup>Released on **2025-11-07**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Don't include runtimeProvider in JWT for non-image operations."
+      ]
+    },
+    "date": "2025-11-07",
+    "version": "2.0.0-next.37"
+  },
+  {
+    "children": {
+      "features": [
+        "Refactor to use agent runtime as the generation core and support branch mode."
+      ]
+    },
+    "date": "2025-11-07",
+    "version": "2.0.0-next.36"
+  },
   {
     "children": {
       "improvements": [

package/next.config.ts

@@ -36,7 +36,6 @@ const nextConfig: NextConfig = {
       '@icons-pack/react-simple-icons',
       '@lobehub/ui',
       '@lobehub/icons',
-      'gpt-tokenizer',
     ],
     // oidc provider depend on constructor.name
     // but swc minification will remove the name
@@ -269,7 +268,7 @@ const nextConfig: NextConfig = {
   ],
 
   // when external packages in dev mode with turbopack, this config will lead to bundle error
-  serverExternalPackages: isProd ? ['@electric-sql/pglite', "pdfkit"] : ["pdfkit"],
+  serverExternalPackages: isProd ? ['@electric-sql/pglite', 'pdfkit'] : ['pdfkit'],
   transpilePackages: ['pdfjs-dist', 'mermaid'],
   turbopack: {},
 
@@ -335,10 +334,10 @@ const withBundleAnalyzer = process.env.ANALYZE === 'true' ? analyzer() : noWrapp
 const withPWA =
   isProd && !isDesktop
     ? withSerwistInit({
-      register: false,
-      swDest: 'public/sw.js',
-      swSrc: 'src/app/sw.ts',
-    })
+        register: false,
+        swDest: 'public/sw.js',
+        swSrc: 'src/app/sw.ts',
+      })
     : noWrapper;
 
 export default withBundleAnalyzer(withPWA(nextConfig as NextConfig));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.35",
+  "version": "2.0.0-next.37",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -150,6 +150,7 @@
     "@lobechat/agent-runtime": "workspace:*",
     "@lobechat/const": "workspace:*",
     "@lobechat/context-engine": "workspace:*",
+    "@lobechat/conversation-flow": "workspace:*",
     "@lobechat/database": "workspace:*",
     "@lobechat/electron-client-ipc": "workspace:*",
     "@lobechat/electron-server-ipc": "workspace:*",
@@ -208,7 +209,6 @@
     "fflate": "^0.8.2",
     "file-type": "^21.0.0",
     "framer-motion": "^12.23.24",
-    "gpt-tokenizer": "^3.2.0",
     "gray-matter": "^4.0.3",
     "html-to-text": "^9.0.5",
     "i18next": "^25.6.0",

package/packages/agent-runtime/src/core/__tests__/runtime.test.ts

@@ -117,13 +117,12 @@ describe('AgentRuntime', () => {
       const runtime = new AgentRuntime(agent);
       const state = AgentRuntime.createInitialState({ sessionId: 'test-session' });
 
-      const toolCall: ToolsCalling = {
+      const toolCall = {
         id: 'call_123',
-        type: 'function',
-        function: {
-          name: 'test_tool',
-          arguments: '{"input": "test"}',
-        },
+        apiName: 'test_tool',
+        identifier: 'test_tool',
+        arguments: '{"input": "test"}',
+        type: 'default' as const,
       };
 
       const result = await runtime.approveToolCall(state, toolCall);
@@ -288,13 +287,12 @@ describe('AgentRuntime', () => {
         const runtime = new AgentRuntime(agent);
         const state = AgentRuntime.createInitialState({ sessionId: 'test-session' });
 
-        const toolCall: ToolsCalling = {
+        const toolCall = {
           id: 'call_123',
-          type: 'function',
-          function: {
-            name: 'calculator',
-            arguments: '{"expression": "2+2"}',
-          },
+          apiName: 'calculator',
+          identifier: 'calculator',
+          arguments: '{"expression": "2+2"}',
+          type: 'default' as const,
         };
 
         const result = await runtime.approveToolCall(state, toolCall);
@@ -320,13 +318,12 @@ describe('AgentRuntime', () => {
         const runtime = new AgentRuntime(agent);
         const state = AgentRuntime.createInitialState({ sessionId: 'test-session' });
 
-        const toolCall: ToolsCalling = {
+        const toolCall = {
           id: 'call_123',
-          type: 'function',
-          function: {
-            name: 'unknown_tool',
-            arguments: '{}',
-          },
+          apiName: 'unknown_tool',
+          identifier: 'unknown_tool',
+          arguments: '{}',
+          type: 'default' as const,
         };
 
         const result = await runtime.approveToolCall(state, toolCall);
@@ -1022,7 +1019,14 @@ describe('AgentRuntime', () => {
       expect(result.newState.pendingToolsCalling).toHaveLength(1);
 
       // Step 2: Approve and execute tool call
-      const toolCall = result.newState.pendingToolsCalling![0];
+      const pendingToolCall = result.newState.pendingToolsCalling![0];
+      const toolCall = {
+        id: pendingToolCall.id,
+        apiName: pendingToolCall.function.name,
+        identifier: pendingToolCall.function.name,
+        arguments: pendingToolCall.function.arguments,
+        type: 'default' as const,
+      };
       result = await runtime.approveToolCall(result.newState, toolCall);
 
       // Should have executed tool
@@ -1121,17 +1125,27 @@ describe('AgentRuntime', () => {
             return [
               {
                 payload: {
-                  id: 'call_1',
-                  type: 'function' as const,
-                  function: { name: 'tool_1', arguments: '{}' },
+                  parentMessageId: 'user-msg-id',
+                  toolCalling: {
+                    id: 'call_1',
+                    type: 'default' as const,
+                    apiName: 'tool_1',
+                    identifier: 'tool_1',
+                    arguments: '{}',
+                  },
                 },
                 type: 'call_tool' as const,
               },
               {
                 payload: {
-                  id: 'call_2',
-                  type: 'function' as const,
-                  function: { name: 'tool_2', arguments: '{}' },
+                  parentMessageId: 'user-msg-id',
+                  toolCalling: {
+                    id: 'call_2',
+                    type: 'default' as const,
+                    apiName: 'tool_2',
+                    identifier: 'tool_2',
+                    arguments: '{}',
+                  },
                 },
                 type: 'call_tool' as const,
               },
@@ -1175,9 +1189,14 @@ describe('AgentRuntime', () => {
             return [
               {
                 payload: {
-                  id: 'call_safe',
-                  type: 'function' as const,
-                  function: { name: 'safe_tool', arguments: '{}' },
+                  parentMessageId: 'user-msg-id',
+                  toolCalling: {
+                    id: 'call_safe',
+                    type: 'default' as const,
+                    apiName: 'safe_tool',
+                    identifier: 'safe_tool',
+                    arguments: '{}',
+                  },
                 },
                 type: 'call_tool' as const,
               },
@@ -1252,18 +1271,25 @@ describe('AgentRuntime', () => {
         async runner(context: AgentRuntimeContext, _state: AgentState) {
           if (context.phase === 'user_input') {
             return {
-              payload: [
-                {
-                  id: 'call_expensive',
-                  type: 'function' as const,
-                  function: { name: 'expensive_tool', arguments: '{}' },
-                },
-                {
-                  id: 'call_cheap',
-                  type: 'function' as const,
-                  function: { name: 'cheap_tool', arguments: '{}' },
-                },
-              ],
+              payload: {
+                parentMessageId: 'user-msg-id',
+                toolsCalling: [
+                  {
+                    id: 'call_expensive',
+                    type: 'default' as const,
+                    apiName: 'expensive_tool',
+                    identifier: 'expensive_tool',
+                    arguments: '{}',
+                  },
+                  {
+                    id: 'call_cheap',
+                    type: 'default' as const,
+                    apiName: 'cheap_tool',
+                    identifier: 'cheap_tool',
+                    arguments: '{}',
+                  },
+                ],
+              },
               type: 'call_tools_batch' as const,
             };
           }
@@ -1380,11 +1406,14 @@ describe('AgentRuntime', () => {
           if (context.phase === 'user_input') {
             return {
               payload: {
-                apiName: 'expensive_tool',
-                arguments: '{}',
-                id: 'call_1',
-                identifier: 'expensive_tool',
-                type: 'default' as const,
+                parentMessageId: 'user-msg-id',
+                toolCalling: {
+                  apiName: 'expensive_tool',
+                  arguments: '{}',
+                  id: 'call_1',
+                  identifier: 'expensive_tool',
+                  type: 'default' as const,
+                },
               },
               type: 'call_tool' as const,
             };
@@ -1458,22 +1487,25 @@ describe('AgentRuntime', () => {
         async runner(context: AgentRuntimeContext, _state: AgentState) {
           if (context.phase === 'user_input') {
             return {
-              payload: [
-                {
-                  apiName: 'tool_1',
-                  arguments: '{}',
-                  id: 'call_1',
-                  identifier: 'tool_1',
-                  type: 'default' as const,
-                },
-                {
-                  apiName: 'tool_2',
-                  arguments: '{}',
-                  id: 'call_2',
-                  identifier: 'tool_2',
-                  type: 'default' as const,
-                },
-              ],
+              payload: {
+                parentMessageId: 'user-msg-id',
+                toolsCalling: [
+                  {
+                    apiName: 'tool_1',
+                    arguments: '{}',
+                    id: 'call_1',
+                    identifier: 'tool_1',
+                    type: 'default' as const,
+                  },
+                  {
+                    apiName: 'tool_2',
+                    arguments: '{}',
+                    id: 'call_2',
+                    identifier: 'tool_2',
+                    type: 'default' as const,
+                  },
+                ],
+              },
               type: 'call_tools_batch' as const,
             };
           }
@@ -1535,22 +1567,25 @@ describe('AgentRuntime', () => {
         async runner(context: AgentRuntimeContext, _state: AgentState) {
           if (context.phase === 'user_input') {
             return {
-              payload: [
-                {
-                  apiName: 'analytics_tool',
-                  arguments: '{}',
-                  id: 'call_analytics',
-                  identifier: 'analytics_tool',
-                  type: 'default' as const,
-                },
-                {
-                  apiName: 'logging_tool',
-                  arguments: '{}',
-                  id: 'call_logging',
-                  identifier: 'logging_tool',
-                  type: 'default' as const,
-                },
-              ],
+              payload: {
+                parentMessageId: 'user-msg-id',
+                toolsCalling: [
+                  {
+                    apiName: 'analytics_tool',
+                    arguments: '{}',
+                    id: 'call_analytics',
+                    identifier: 'analytics_tool',
+                    type: 'default' as const,
+                  },
+                  {
+                    apiName: 'logging_tool',
+                    arguments: '{}',
+                    id: 'call_logging',
+                    identifier: 'logging_tool',
+                    type: 'default' as const,
+                  },
+                ],
+              },
               type: 'call_tools_batch' as const,
             };
           }

package/packages/agent-runtime/src/core/runtime.ts

@@ -1,10 +1,16 @@
-import type {
+import { ChatToolPayload } from '@lobechat/types';
+import pMap from 'p-map';
+
+import {
   Agent,
   AgentEvent,
   AgentInstruction,
+  AgentInstructionCallTool,
+  AgentInstructionCallToolsBatch,
   AgentRuntimeContext,
   AgentState,
   Cost,
+  GeneralAgentCallToolsBatchResultPayload,
   InstructionExecutor,
   RuntimeConfig,
   ToolRegistry,
@@ -79,8 +85,16 @@ export class AgentRuntime {
 
       // Handle human approved tool calls
       if (runtimeContext.phase === 'human_approved_tool') {
-        const approvedPayload = runtimeContext.payload as { approvedToolCall: ToolsCalling };
-        rawInstructions = { payload: approvedPayload.approvedToolCall, type: 'call_tool' };
+        const approvedPayload = runtimeContext.payload as { approvedToolCall: ChatToolPayload };
+        const toolCalling = approvedPayload.approvedToolCall;
+
+        rawInstructions = {
+          payload: {
+            parentMessageId: '', // Not required for approval flow
+            toolCalling,
+          },
+          type: 'call_tool',
+        };
       } else {
         // Standard flow: Plan -> Execute
         rawInstructions = await this.agent.runner(runtimeContext, newState);
@@ -89,12 +103,37 @@ export class AgentRuntime {
       // Normalize to array
       const instructions = Array.isArray(rawInstructions) ? rawInstructions : [rawInstructions];
 
+      // Convert old format to new format
+      const normalizedInstructions = instructions.map((instruction) => {
+        if (
+          instruction.type === 'call_tools_batch' && // Check if payload is array of ToolsCalling (old format)
+          Array.isArray(instruction.payload)
+        ) {
+          const toolsCalling = instruction.payload.map((tc: ToolsCalling) => ({
+            apiName: tc.function.name,
+            arguments: tc.function.arguments,
+            id: tc.id,
+            identifier: tc.function.name,
+            type: 'default' as any,
+          }));
+
+          return {
+            payload: {
+              parentMessageId: '',
+              toolsCalling,
+            },
+            type: 'call_tools_batch',
+          };
+        }
+        return instruction;
+      });
+
       // Execute all instructions sequentially
       let currentState = newState;
       const allEvents: AgentEvent[] = [];
       let finalNextContext: AgentRuntimeContext | undefined = undefined;
 
-      for (const instruction of instructions) {
+      for (const instruction of normalizedInstructions) {
         let result;
 
         // Special handling for batch tool execution
@@ -147,7 +186,7 @@ export class AgentRuntime {
    */
   async approveToolCall(
     state: AgentState,
-    approvedToolCall: any,
+    approvedToolCall: ChatToolPayload,
   ): Promise<{ events: AgentEvent[]; newState: AgentState; nextContext?: AgentRuntimeContext }> {
     const context: AgentRuntimeContext = {
       payload: { approvedToolCall },
@@ -414,7 +453,7 @@ export class AgentRuntime {
   /** Create call_tool executor */
   private createCallToolExecutor(): InstructionExecutor {
     return async (instruction, state) => {
-      const { payload: toolCall } = instruction as Extract<AgentInstruction, { type: 'call_tool' }>;
+      const { payload } = instruction as AgentInstructionCallTool;
       const newState = structuredClone(state);
       const events: AgentEvent[] = [];
 
@@ -423,9 +462,10 @@ export class AgentRuntime {
 
       const tools = this.agent.tools || ({} as ToolRegistry);
 
+      const toolCall = payload.toolCalling;
       // Support both ToolsCalling (OpenAI format) and CallingToolPayload formats
-      const toolName = toolCall.apiName || toolCall.function?.name;
-      const toolArgs = toolCall.arguments || toolCall.function?.arguments;
+      const toolName = toolCall.apiName;
+      const toolArgs = toolCall.arguments;
       const toolId = toolCall.id;
 
       const handler = tools[toolName];
@@ -586,27 +626,30 @@ export class AgentRuntime {
    * Execute multiple tool calls concurrently
    */
   private async executeToolsBatch(
-    instruction: { payload: any[]; type: 'call_tools_batch' },
+    instruction: AgentInstructionCallToolsBatch,
     baseState: AgentState,
   ): Promise<{
     events: AgentEvent[];
     newState: AgentState;
     nextContext?: AgentRuntimeContext;
   }> {
-    const { payload: toolsCalling } = instruction;
+    const { payload } = instruction;
 
     // Execute all tools concurrently based on the same state
-    const results = await Promise.all(
-      toolsCalling.map((toolCall) =>
-        this.executors.call_tool(
-          { payload: toolCall, type: 'call_tool' } as any,
-          structuredClone(baseState), // Each tool starts from the same base state
-        ),
+    const results = await pMap(instruction.payload.toolsCalling, (toolCalling: ChatToolPayload) =>
+      this.executors.call_tool(
+        {
+          payload: { parentMessageId: payload.parentMessageId, toolCalling },
+          type: 'call_tool',
+        } as AgentInstructionCallTool,
+        structuredClone(baseState), // Each tool starts from the same base state
       ),
     );
 
+    const lastParentMessageId = (results.at(-1)!.nextContext?.payload as any)
+      ?.parentMessageId as string;
     // Merge results
-    return this.mergeToolResults(results, baseState);
+    return this.mergeToolResults(results, baseState, lastParentMessageId);
   }
 
   /**
@@ -619,6 +662,7 @@ export class AgentRuntime {
       nextContext?: AgentRuntimeContext;
     }>,
     baseState: AgentState,
+    lastParentMessageId: string,
   ): {
     events: AgentEvent[];
     newState: AgentState;
@@ -679,9 +723,10 @@ export class AgentRuntime {
       newState,
       nextContext: {
         payload: {
+          parentMessageId: lastParentMessageId,
           toolCount: results.length,
           toolResults: results.map((r) => r.nextContext?.payload),
-        },
+        } as GeneralAgentCallToolsBatchResultPayload,
         phase: 'tools_batch_result',
         session: this.createSessionContext(newState),
       },

package/packages/agent-runtime/src/types/generalAgent.ts

@@ -0,0 +1,55 @@
+import { ChatToolPayload, MessageToolCall } from '@lobechat/types';
+
+export interface GeneralAgentCallLLMInstructionPayload {
+  isFirstMessage?: boolean;
+  messages: any[];
+  model: string;
+  parentMessageId?: string;
+  provider: string;
+  tools: any[];
+}
+
+export interface GeneralAgentCallLLMResultPayload {
+  hasToolsCalling: boolean;
+  parentMessageId: string;
+  result: { content: string; tool_calls: MessageToolCall[] };
+  toolsCalling: ChatToolPayload[];
+}
+
+export interface GeneralAgentCallingToolInstructionPayload {
+  parentMessageId: string;
+  toolCalling: ChatToolPayload;
+}
+
+export interface GeneralAgentCallToolResultPayload {
+  data: any;
+  executionTime: number;
+  isSuccess: boolean;
+  parentMessageId: string;
+  toolCall: ChatToolPayload;
+  toolCallId: string;
+}
+
+export interface GeneralAgentCallToolsBatchInstructionPayload {
+  parentMessageId: string;
+  toolsCalling: ChatToolPayload[];
+}
+
+export interface GeneralAgentCallToolsBatchResultPayload {
+  parentMessageId: string;
+  toolCount: number;
+  toolResults: GeneralAgentCallToolResultPayload[];
+}
+
+export interface GeneralAgentConfig {
+  agentConfig?: {
+    [key: string]: any;
+    maxSteps?: number;
+  };
+  modelRuntimeConfig?: {
+    model: string;
+    provider: string;
+  };
+  sessionId: string;
+  userId?: string;
+}

package/packages/agent-runtime/src/types/index.ts

@@ -1,4 +1,5 @@
 export * from './event';
+export * from './generalAgent';
 export * from './instruction';
 export * from './runtime';
 export * from './state';

package/packages/agent-runtime/src/types/instruction.ts

@@ -1,4 +1,4 @@
-import type { ModelUsage } from '@lobechat/types';
+import { ChatToolPayload, ModelUsage } from '@lobechat/types';
 
 import type { FinishReason } from './event';
 import { AgentState, ToolRegistry, ToolsCalling } from './state';
@@ -86,6 +86,7 @@ export interface CallLLMPayload {
   isFirstMessage?: boolean;
   messages: any[];
   model: string;
+  parentId?: string;
   provider: string;
   tools: any[];
 }
@@ -104,12 +105,18 @@ export interface AgentInstructionCallLlm {
 }
 
 export interface AgentInstructionCallTool {
-  payload: any;
+  payload: {
+    parentMessageId: string;
+    toolCalling: ChatToolPayload;
+  };
   type: 'call_tool';
 }
 
 export interface AgentInstructionCallToolsBatch {
-  payload: any[];
+  payload: {
+    parentMessageId: string;
+    toolsCalling: ChatToolPayload[];
+  } & any;
   type: 'call_tools_batch';
 }
 

package/packages/const/src/user.ts

@@ -6,7 +6,6 @@ export const DEFAULT_PREFERENCE: UserPreference = {
     topic: true,
   },
   lab: {
-    enableAssistantMessageGroup: false,
     enableGroupChat: false,
     enableInputMarkdown: true,
   },