@lobehub/lobehub 2.0.0-next.334 → 2.0.0-next.336

package/src/store/chat/slices/aiChat/actions/__tests__/streamingExecutor.test.ts

@@ -13,6 +13,7 @@ import {
   createMockAgentConfig,
   createMockChatConfig,
   createMockMessage,
+  createMockResolvedAgentConfig,
 } from './fixtures';
 import { resetTestEnvironment, setupMockSelectors, spyOnMessageService } from './helpers';
 
@@ -57,6 +58,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
         expect(response.isFunctionCall).toEqual(false);
         expect(response.content).toEqual(TEST_CONTENT.AI_RESPONSE);
@@ -83,6 +85,7 @@ describe('StreamingExecutor actions', () => {
           provider: 'openai',
           messages,
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -127,6 +130,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
         expect(response.isFunctionCall).toEqual(true);
       });
@@ -165,6 +169,7 @@ describe('StreamingExecutor actions', () => {
           model: 'gpt-4o-mini',
           provider: 'openai',
           operationId,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -213,6 +218,7 @@ describe('StreamingExecutor actions', () => {
           model: 'gpt-4o-mini',
           provider: 'openai',
           operationId,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -251,6 +257,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -300,6 +307,7 @@ describe('StreamingExecutor actions', () => {
           model: 'gpt-4o-mini',
           provider: 'openai',
           operationId,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -355,6 +363,7 @@ describe('StreamingExecutor actions', () => {
           model: 'gpt-4o-mini',
           provider: 'openai',
           operationId,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -394,6 +403,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
         expect(response.isFunctionCall).toEqual(true);
       });
@@ -419,6 +429,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -435,7 +446,7 @@ describe('StreamingExecutor actions', () => {
     });
 
     describe('effectiveAgentId for group orchestration', () => {
-      it('should pass effectiveAgentId (subAgentId) to chatService when subAgentId is set in operation context', async () => {
+      it('should pass pre-resolved config for sub-agent when subAgentId is set in operation context', async () => {
         const { result } = renderHook(() => useChatStore());
         const messages = [createMockMessage({ role: 'user' })];
         const supervisorAgentId = 'supervisor-agent-id';
@@ -453,6 +464,9 @@ describe('StreamingExecutor actions', () => {
           label: 'Test Group Orchestration',
         });
 
+        // Pre-resolved config for the sub-agent (in real usage, resolved by internal_createAgentState)
+        const subAgentConfig = createMockResolvedAgentConfig();
+
         const streamSpy = vi
           .spyOn(chatService, 'createAssistantMessageStream')
           .mockImplementation(async ({ onFinish }) => {
@@ -466,14 +480,18 @@ describe('StreamingExecutor actions', () => {
             model: 'gpt-4o-mini',
             provider: 'openai',
             operationId,
+            agentConfig: subAgentConfig,
           });
         });
 
-        // Verify chatService was called with subAgentId (effectiveAgentId), not supervisorAgentId
+        // With the new architecture:
+        // - agentId param is for context/tracing (supervisor ID)
+        // - resolvedAgentConfig contains the sub-agent's config (passed in by caller)
         expect(streamSpy).toHaveBeenCalledWith(
           expect.objectContaining({
             params: expect.objectContaining({
-              agentId: subAgentId, // Should be subAgentId, not supervisorAgentId
+              agentId: supervisorAgentId, // For context/tracing purposes
+              resolvedAgentConfig: subAgentConfig, // Pre-resolved sub-agent config
             }),
           }),
         );
@@ -511,6 +529,7 @@ describe('StreamingExecutor actions', () => {
             model: 'gpt-4o-mini',
             provider: 'openai',
             operationId,
+            agentConfig: createMockResolvedAgentConfig(),
           });
         });
 
@@ -526,7 +545,7 @@ describe('StreamingExecutor actions', () => {
         streamSpy.mockRestore();
       });
 
-      it('should use subAgentId for agent config resolution when present', async () => {
+      it('should pass resolvedAgentConfig through chatService when subAgentId is present', async () => {
         const { result } = renderHook(() => useChatStore());
         const messages = [createMockMessage({ role: 'user' })];
         const supervisorAgentId = 'supervisor-agent-id';
@@ -547,6 +566,9 @@ describe('StreamingExecutor actions', () => {
           label: 'Test Speak Executor',
         });
 
+        // Create a mock resolved config that represents the speaking agent's config
+        const speakingAgentConfig = createMockResolvedAgentConfig();
+
         const streamSpy = vi
           .spyOn(chatService, 'createAssistantMessageStream')
           .mockImplementation(async ({ onFinish }) => {
@@ -560,15 +582,23 @@ describe('StreamingExecutor actions', () => {
             model: 'gpt-4o-mini',
             provider: 'openai',
             operationId,
+            // Pass pre-resolved config for the speaking agent
+            // In real usage, this is resolved in internal_createAgentState using subAgentId
+            agentConfig: speakingAgentConfig,
           });
         });
 
-        // The key assertion: chatService should receive subAgentId for agent config resolution
-        // This ensures the speaking agent's system role and tools are used, not the supervisor's
+        // With the new architecture, config is pre-resolved and passed via resolvedAgentConfig.
+        // The agentId param is for context/tracing only.
+        // The speaking agent's config is ensured by the caller (internal_createAgentState)
+        // resolving config with subAgentId and passing it as agentConfig param.
         expect(streamSpy).toHaveBeenCalledWith(
           expect.objectContaining({
             params: expect.objectContaining({
-              agentId: subAgentId,
+              // agentId is supervisor for context purposes
+              agentId: supervisorAgentId,
+              // resolvedAgentConfig contains the speaking agent's config
+              resolvedAgentConfig: speakingAgentConfig,
             }),
           }),
         );
@@ -902,6 +932,7 @@ describe('StreamingExecutor actions', () => {
           model: 'gpt-4o-mini',
           provider: 'openai',
           operationId,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -943,6 +974,7 @@ describe('StreamingExecutor actions', () => {
           messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           model: 'gpt-4o-mini',
           provider: 'openai',
+          agentConfig: createMockResolvedAgentConfig(),
         });
       });
 
@@ -1040,6 +1072,7 @@ describe('StreamingExecutor actions', () => {
             stepCount: 0,
           },
         },
+        agentConfig: createMockResolvedAgentConfig(),
       });
 
       // Execute internal_execAgentRuntime with the pre-created operationId
@@ -1135,6 +1168,7 @@ describe('StreamingExecutor actions', () => {
             stepCount: 0,
           },
         },
+        agentConfig: createMockResolvedAgentConfig(),
       });
 
       // Suppress console.error for this test
@@ -1235,6 +1269,7 @@ describe('StreamingExecutor actions', () => {
             stepCount: 0,
           },
         },
+        agentConfig: createMockResolvedAgentConfig(),
       });
 
       // Should not throw
@@ -1489,6 +1524,7 @@ describe('StreamingExecutor actions', () => {
             stepCount: 1,
           },
         },
+        agentConfig: createMockResolvedAgentConfig(),
       });
 
       await act(async () => {
@@ -1583,6 +1619,7 @@ describe('StreamingExecutor actions', () => {
             stepCount: 1,
           },
         },
+        agentConfig: createMockResolvedAgentConfig(),
       });
 
       await act(async () => {
@@ -1602,4 +1639,91 @@ describe('StreamingExecutor actions', () => {
       expect(result.current.operations[operationId!].status).toBe('failed');
     });
   });
+
+  describe('isSubTask filtering', () => {
+    it('should filter out lobe-gtd tools when isSubTask is true', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const messages = [createMockMessage({ role: 'user' })];
+
+      // Mock resolveAgentConfig to return plugins including lobe-gtd
+      const resolveAgentConfigSpy = vi
+        .spyOn(agentConfigResolver, 'resolveAgentConfig')
+        .mockReturnValue({
+          agentConfig: createMockAgentConfig(),
+          chatConfig: createMockChatConfig(),
+          isBuiltinAgent: false,
+          plugins: ['lobe-gtd', 'lobe-local-system', 'other-plugin'],
+        });
+
+      // Create operation
+      let operationId: string;
+      act(() => {
+        const res = result.current.startOperation({
+          type: 'execClientTask',
+          context: {
+            agentId: TEST_IDS.SESSION_ID,
+            topicId: TEST_IDS.TOPIC_ID,
+          },
+        });
+        operationId = res.operationId;
+      });
+
+      // Call internal_createAgentState with isSubTask: true
+      act(() => {
+        result.current.internal_createAgentState({
+          messages,
+          parentMessageId: TEST_IDS.USER_MESSAGE_ID,
+          operationId,
+          isSubTask: true,
+        });
+      });
+
+      // Verify that resolveAgentConfig was called
+      expect(resolveAgentConfigSpy).toHaveBeenCalled();
+
+      resolveAgentConfigSpy.mockRestore();
+    });
+
+    it('should NOT filter out lobe-gtd tools when isSubTask is false or undefined', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const messages = [createMockMessage({ role: 'user' })];
+
+      // Mock resolveAgentConfig to return plugins including lobe-gtd
+      const resolveAgentConfigSpy = vi
+        .spyOn(agentConfigResolver, 'resolveAgentConfig')
+        .mockReturnValue({
+          agentConfig: createMockAgentConfig(),
+          chatConfig: createMockChatConfig(),
+          isBuiltinAgent: false,
+          plugins: ['lobe-gtd', 'lobe-local-system', 'other-plugin'],
+        });
+
+      // Create operation without isSubTask (normal conversation)
+      let operationId: string;
+      act(() => {
+        const res = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: {
+            agentId: TEST_IDS.SESSION_ID,
+            topicId: TEST_IDS.TOPIC_ID,
+          },
+        });
+        operationId = res.operationId;
+      });
+
+      // Call internal_createAgentState without isSubTask
+      act(() => {
+        result.current.internal_createAgentState({
+          messages,
+          parentMessageId: TEST_IDS.USER_MESSAGE_ID,
+          operationId,
+        });
+      });
+
+      // Verify that resolveAgentConfig was called
+      expect(resolveAgentConfigSpy).toHaveBeenCalled();
+
+      resolveAgentConfigSpy.mockRestore();
+    });
+  });
 });

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -28,7 +28,7 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { createAgentToolsEngine } from '@/helpers/toolEngineering';
 import { chatService } from '@/services/chat';
-import { resolveAgentConfig } from '@/services/chat/mecha';
+import { type ResolvedAgentConfig, resolveAgentConfig } from '@/services/chat/mecha';
 import { messageService } from '@/services/message';
 import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
 import { type ChatStore } from '@/store/chat/store';
@@ -72,9 +72,15 @@ export interface StreamingExecutorAction {
      * Used to get Agent config (model, provider, plugins) instead of agentId
      */
     subAgentId?: string;
+    /**
+     * Whether this is a sub-task execution (disables lobe-gtd tools to prevent nested sub-tasks)
+     */
+    isSubTask?: boolean;
   }) => {
     state: AgentState;
     context: AgentRuntimeContext;
+    /** Resolved agent config with isSubTask filtering applied */
+    agentConfig: ResolvedAgentConfig;
   };
   /**
    * Retrieves an AI-generated chat message from the backend service with streaming
@@ -85,7 +91,8 @@ export interface StreamingExecutorAction {
     model: string;
     provider: string;
     operationId?: string;
-    agentConfig?: any;
+    /** Pre-resolved agent config (from internal_createAgentState) with isSubTask filtering applied */
+    agentConfig: ResolvedAgentConfig;
     traceId?: string;
     /** Initial context for page editor (captured at operation start) */
     initialContext?: RuntimeInitialContext;
@@ -132,6 +139,10 @@ export interface StreamingExecutorAction {
      */
     parentOperationId?: string;
     skipCreateFirstMessage?: boolean;
+    /**
+     * Whether this is a sub-task execution (disables lobe-gtd tools to prevent nested sub-tasks)
+     */
+    isSubTask?: boolean;
   }) => Promise<{ cost?: Cost; usage?: Usage } | void>;
 }
 
@@ -151,6 +162,7 @@ export const streamingExecutor: StateCreator<
     initialContext,
     operationId,
     subAgentId: paramSubAgentId,
+    isSubTask,
   }) => {
     // Use provided agentId/topicId or fallback to global state
     const { activeAgentId, activeTopicId } = get();
@@ -169,11 +181,16 @@ export const streamingExecutor: StateCreator<
 
     // Resolve agent config with builtin agent runtime config merged
     // This ensures runtime plugins (e.g., 'lobe-agent-builder' for Agent Builder) are included
-    const { agentConfig: agentConfigData, plugins: pluginIds } = resolveAgentConfig({
+    // isSubTask is passed to filter out lobe-gtd tools to prevent nested sub-task creation
+    const agentConfig = resolveAgentConfig({
       agentId: effectiveAgentId || '',
       groupId, // Pass groupId for supervisor detection
+      isSubTask, // Filter out lobe-gtd in sub-task context
       scope, // Pass scope from operation context
     });
+    const { agentConfig: agentConfigData, plugins: pluginIds } = agentConfig;
+
+    log('[internal_createAgentState] resolved plugins=%o, isSubTask=%s', pluginIds, isSubTask);
 
     // Get tools manifest map
     const toolsEngine = createAgentToolsEngine({
@@ -260,7 +277,7 @@ export const streamingExecutor: StateCreator<
       initialContext: runtimeInitialContext,
     };
 
-    return { state, context };
+    return { state, context, agentConfig };
   },
 
   internal_fetchAIChatMessage: async ({
@@ -333,23 +350,10 @@ export const streamingExecutor: StateCreator<
     // Create base context for child operations and message queries
     const fetchContext = { agentId, topicId, threadId, groupId, scope };
 
-    // For group orchestration scenarios:
-    // - subAgentId is used for agent config retrieval (model, provider, plugins)
-    // - agentId is used for session ID (message storage location)
-    const effectiveAgentId = subAgentId || agentId;
-
-    // Resolve agent config with params adjusted based on chatConfig
-    // If agentConfig is passed in, use it directly (it's already resolved)
-    // Otherwise, resolve from mecha layer which handles:
-    // - Builtin agent runtime config merging
-    // - max_tokens/reasoning_effort based on chatConfig settings
-    const resolved = resolveAgentConfig({
-      agentId: effectiveAgentId,
-      groupId, // Pass groupId for supervisor detection
-      scope, // scope is already available from line 329
-    });
-    const finalAgentConfig = agentConfig || resolved.agentConfig;
-    const chatConfig = resolved.chatConfig;
+    // Use pre-resolved agent config (from internal_createAgentState)
+    // This ensures isSubTask filtering and other runtime modifications are preserved
+    const { agentConfig: agentConfigData, chatConfig, plugins: pluginIds } = agentConfig;
+    log('[internal_fetchAIChatMessage] using pre-resolved config, plugins=%o', pluginIds);
 
     let finalUsage: ModelUsage | undefined;
     let finalToolCalls: MessageToolCall[] | undefined;
@@ -437,18 +441,18 @@ export const streamingExecutor: StateCreator<
     await chatService.createAssistantMessageStream({
       abortController,
       params: {
-        // Use effectiveAgentId for agent config resolution (system role, tools, etc.)
-        // In group orchestration: subAgentId for the actual speaking agent
-        // In normal chat: agentId for the main agent
-        agentId: effectiveAgentId || undefined,
+        // agentId is used for context, not for config resolution (config is pre-resolved)
+        agentId: agentId || undefined,
         groupId,
         messages,
         model,
         provider,
+        // Pass pre-resolved config to avoid duplicate resolveAgentConfig calls
+        // This ensures isSubTask filtering and other runtime modifications are preserved
+        resolvedAgentConfig: agentConfig,
         scope, // Pass scope to chat service for page-agent injection
-        topicId, // Pass topicId for GTD context injection
-        ...finalAgentConfig.params,
-        plugins: finalAgentConfig.plugins,
+        topicId: topicId ?? undefined, // Pass topicId for GTD context injection
+        ...agentConfigData.params,
       },
       historySummary: historySummary?.content,
       // Pass page editor context from agent runtime
@@ -544,7 +548,13 @@ export const streamingExecutor: StateCreator<
   },
 
   internal_execAgentRuntime: async (params) => {
-    const { messages: originalMessages, parentMessageId, parentMessageType, context } = params;
+    const {
+      messages: originalMessages,
+      parentMessageId,
+      parentMessageType,
+      context,
+      isSubTask,
+    } = params;
 
     // Extract values from context
     const { agentId, topicId, threadId, subAgentId, groupId } = context;
@@ -593,30 +603,32 @@ export const streamingExecutor: StateCreator<
     // Create a new array to avoid modifying the original messages
     let messages = [...originalMessages];
 
-    // Use effectiveAgentId to get agent config (subAgentId in group orchestration, agentId otherwise)
-    // resolveAgentConfig handles:
-    // - Builtin agent runtime config merging
-    // - max_tokens/reasoning_effort based on chatConfig settings
-    const { agentConfig: agentConfigData } = resolveAgentConfig({
-      agentId: effectiveAgentId || '',
-      groupId, // Pass groupId for supervisor detection
-      scope: context.scope, // Pass scope from context parameter
+    // ===========================================
+    // Step 1: Create Agent State (resolves config once)
+    // ===========================================
+    // agentConfig contains isSubTask filtering and is passed to callLLM executor
+    const {
+      state: initialAgentState,
+      context: initialAgentContext,
+      agentConfig,
+    } = get().internal_createAgentState({
+      messages,
+      parentMessageId: params.parentMessageId,
+      agentId,
+      topicId,
+      threadId: threadId ?? undefined,
+      initialState: params.initialState,
+      initialContext: params.initialContext,
+      operationId,
+      subAgentId, // Pass subAgentId for agent config retrieval
+      isSubTask, // Pass isSubTask to filter out lobe-gtd tools in sub-task context
     });
 
-    // Use agent config from agentId
+    // Use model/provider from resolved agentConfig
+    const { agentConfig: agentConfigData } = agentConfig;
     const model = agentConfigData.model;
     const provider = agentConfigData.provider;
 
-    // ===========================================
-    // Step 1: Knowledge Base Tool Integration
-    // ===========================================
-    // RAG retrieval is now handled by the Knowledge Base Tool
-    // The AI will decide when to call searchKnowledgeBase and readKnowledge tools
-    // based on the conversation context and available knowledge bases
-
-    // TODO: Implement selected files full-text injection if needed
-    // User-selected files should be handled differently from knowledge base files
-
     // ===========================================
     // Step 2: Create and Execute Agent Runtime
     // ===========================================
@@ -633,6 +645,7 @@ export const streamingExecutor: StateCreator<
 
     const runtime = new AgentRuntime(agent, {
       executors: createAgentExecutors({
+        agentConfig, // Pass pre-resolved config to callLLM executor
         get,
         messageKey,
         operationId,
@@ -650,20 +663,6 @@ export const streamingExecutor: StateCreator<
       operationId,
     });
 
-    // Create agent state and context with user intervention config
-    const { state: initialAgentState, context: initialAgentContext } =
-      get().internal_createAgentState({
-        messages,
-        parentMessageId: params.parentMessageId,
-        agentId,
-        topicId,
-        threadId: threadId ?? undefined,
-        initialState: params.initialState,
-        initialContext: params.initialContext,
-        operationId,
-        subAgentId, // Pass subAgentId for agent config retrieval
-      });
-
     let state = initialAgentState;
     let nextContext = initialAgentContext;
 

package/src/store/chat/slices/plugin/action.test.ts

@@ -1060,6 +1060,77 @@ describe('ChatPluginAction', () => {
 
       expect(transformed[0].apiName).toBe(longApiName);
     });
+
+    it('should repair malformed JSON arguments with escaped string issue', () => {
+      // This is the malformed data from haiku-4.5 model
+      // The entire JSON got stuffed into the "description" field with escaped quotes
+      const malformedArguments = JSON.stringify({
+        description:
+          'Synthesize all 10 batch analyses into 10 most important themes for product builders", "instruction": "You have access to 10 batch analysis files", "runInClient": true, "timeout": 120000}',
+      });
+
+      const toolCalls: MessageToolCall[] = [
+        {
+          id: 'tool1',
+          function: {
+            name: ['lobe-gtd', 'execTask', 'default'].join(PLUGIN_SCHEMA_SEPARATOR),
+            arguments: malformedArguments,
+          },
+          type: 'function',
+        },
+      ];
+
+      // Setup builtin tool manifest with schema that has required fields
+      act(() => {
+        useToolStore.setState({
+          builtinTools: [
+            {
+              type: 'builtin',
+              identifier: 'lobe-gtd',
+              manifest: {
+                identifier: 'lobe-gtd',
+                api: [
+                  {
+                    name: 'execTask',
+                    description: 'Execute async task',
+                    parameters: {
+                      type: 'object',
+                      required: ['description', 'instruction'],
+                      properties: {
+                        description: { type: 'string' },
+                        instruction: { type: 'string' },
+                        runInClient: { type: 'boolean' },
+                        timeout: { type: 'number' },
+                      },
+                    },
+                  },
+                ],
+                type: 'builtin',
+              } as any,
+            },
+          ],
+        });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+
+      const transformed = result.current.internal_transformToolCalls(toolCalls);
+
+      // Parse the transformed arguments
+      const repairedArgs = JSON.parse(transformed[0].arguments);
+
+      // Verify all fields are correctly extracted
+      expect(repairedArgs).toHaveProperty('description');
+      expect(repairedArgs).toHaveProperty('instruction');
+      expect(repairedArgs).toHaveProperty('runInClient', true);
+      expect(repairedArgs).toHaveProperty('timeout', 120000);
+
+      // Verify description is the correct short value, not the entire malformed string
+      expect(repairedArgs.description).toBe(
+        'Synthesize all 10 batch analyses into 10 most important themes for product builders',
+      );
+      expect(repairedArgs.instruction).toBe('You have access to 10 batch analysis files');
+    });
   });
 
   describe('internal_updatePluginError', () => {

package/src/store/chat/slices/plugin/actions/internals.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
-import { ToolNameResolver } from '@lobechat/context-engine';
+import { ToolArgumentsRepairer, ToolNameResolver } from '@lobechat/context-engine';
 import { type ChatToolPayload, type MessageToolCall } from '@lobechat/types';
 import { type LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { type StateCreator } from 'zustand/vanilla';
@@ -78,9 +78,18 @@ export const pluginInternals: StateCreator<
 
     // Resolve tool calls and add source field
     const resolved = toolNameResolver.resolve(toolCalls, manifests);
-    return resolved.map((payload) => ({
-      ...payload,
-      source: sourceMap[payload.identifier],
-    }));
+
+    return resolved.map((payload) => {
+      // Parse and repair arguments if needed
+      const manifest = manifests[payload.identifier];
+      const repairer = new ToolArgumentsRepairer(manifest);
+      const repairedArgs = repairer.parse(payload.apiName, payload.arguments);
+
+      return {
+        ...payload,
+        arguments: JSON.stringify(repairedArgs),
+        source: sourceMap[payload.identifier],
+      };
+    });
   },
 });