fix(mothership): strip only the display label, and keep a tool's own activity argument

Author: waleedlatif1

apps/sim/lib/mothership/request/handlers/handlers.test.ts

@@ -2252,6 +2252,58 @@ describe('sse-handlers tool lifecycle', () => {
     )
   })
 
+  it("keeps an integration operation's own activity argument under the gateway's grouping", async () => {
+    isSimExecuted.mockReturnValue(false)
+    executeTool.mockResolvedValueOnce({ success: true, output: {} })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'gateway-work-item',
+          toolName: 'call_integration_tool',
+          arguments: {
+            toolId: 'azure_devops_create_work_item',
+            description: 'Filing the task',
+            activity: { id: 'filing', title: 'Filing tasks', completedTitle: 'Filed tasks' },
+            arguments: { title: 'Ship it', activity: 'Development' },
+          },
+          executor: MothershipStreamV1ToolExecutor.go,
+          mode: MothershipStreamV1ToolMode.sync,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'gateway-work-item',
+          toolName: 'azure_devops_create_work_item',
+          arguments: { title: 'Ship it', activity: 'Development' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await sleep(0)
+
+    expect(executeTool).toHaveBeenCalledWith(
+      'azure_devops_create_work_item',
+      { title: 'Ship it', activity: 'Development' },
+      expect.any(Object)
+    )
+  })
+
   it('clears pending continuation state when a run resumes', async () => {
     context.awaitingAsyncContinuation = {
       checkpointId: 'cp-1',

apps/sim/lib/mothership/request/handlers/tool.ts

@@ -587,7 +587,9 @@ async function handleCallPhase(
         .filter((tool) => tool.agentId === agentId && tool.parentToolCallId === parentToolCallId)
         .map((tool) => readToolActivity(tool.params))
         .find((candidate) => candidate?.id === suppliedActivity.id && candidate.completedTitle)
-  const displayArgs = activity ? { ...args, activity } : args
+  // A tool's own `activity` argument (any value that is not a display label) is never replaced.
+  const ownsActivity = args?.activity !== undefined && !readToolActivity(args)
+  const displayArgs = activity && !ownsActivity ? { ...args, activity } : args
   const isSubagent = scope === 'subagent'
   const ui = getToolCallUI(data)
 

apps/sim/lib/mothership/tool-executor/executor.test.ts

@@ -10,7 +10,7 @@ import {
 import { toolsMock, toolsMockFns } from '@sim/testing/mocks/tools.mock'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
-import { getToolMetadata } from '@/tools/metadata'
+import { getToolMetadata, getToolParams } from '@/tools/metadata'
 import { slackGetUserTool } from '@/tools/slack/get_user'
 
 const { getToolEntry, isKnownTool, isSimExecuted, isClientExecuted } = vi.hoisted(() => ({
@@ -313,13 +313,33 @@ describe('copilot tool executor fallback', () => {
     await executeTool(
       'mcp-server-get_overview',
       { activity: { id: 'gauge-read' }, category_id: null },
-      { userId: 'person', workspaceId: 'workspace', requestMode: 'agent' }
+      { userId: 'person', workflowId: '', workspaceId: 'workspace', requestMode: 'agent' }
     )
-    const [, appParams] = executeAppTool.mock.calls[0]
+    const appParams = executeAppTool.mock.calls[0]?.[1]
     expect(appParams).not.toHaveProperty('activity')
     expect(appParams).toMatchObject({ category_id: null })
   })
 
+  it.each([
+    ['a tool that declares it', 'azure_devops_create_work_item', { id: 'Development' }],
+    ['a value that is not a display label', 'mcp-server-log_time', 'Development'],
+  ])("keeps a tool's own activity for %s", async (_case, toolId, activity) => {
+    vi.mocked(getToolParams).mockImplementation((id) =>
+      id === 'azure_devops_create_work_item'
+        ? { activity: { type: 'string', required: false, visibility: 'user-or-llm' } }
+        : undefined
+    )
+    isKnownTool.mockReturnValue(false)
+    isClientExecuted.mockReturnValue(false)
+    executeAppTool.mockResolvedValue({ success: true })
+    await executeTool(
+      toolId,
+      { activity },
+      { userId: 'person', workflowId: '', workspaceId: 'workspace', requestMode: 'agent' }
+    )
+    expect(executeAppTool.mock.calls[0]?.[1]).toMatchObject({ activity })
+  })
+
   it('projects resolved secrets before logging registered handler failures', async () => {
     const secret = 'mounted-secret-value'
     const registry = new ResolvedSecretTraceRegistry([

apps/sim/lib/mothership/tool-executor/executor.ts

@@ -11,10 +11,11 @@ import { createRegistryContentGate } from '@/lib/mothership/content-delivery'
 import { prepareCopilotEnvironmentContext } from '@/lib/mothership/environment-context'
 import { isSearchIntegrationToolsEnabled } from '@/lib/mothership/feature-flags'
 import { isOwnerScopedFile } from '@/lib/mothership/file-owners'
+import { ToolActivity } from '@/lib/mothership/generated/protocol'
 import { projectToolErrorMessageForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
 import { recordSecretUsage } from '@/lib/secrets/usage/record'
 import { executeTool as executeAppTool } from '@/tools'
-import { getToolMetadata } from '@/tools/metadata'
+import { getToolMetadata, getToolParams } from '@/tools/metadata'
 import { getToolEntry, isClientExecuted, isKnownTool, isSimExecuted } from './router'
 import type { ToolExecutionContext, ToolExecutionResult, ToolHandler } from './types'
 
@@ -42,11 +43,9 @@ export function clearHandlers(): void {
 
 export async function executeTool(
   toolId: string,
-  args: Record<string, unknown>,
+  params: Record<string, unknown>,
   context: ToolExecutionContext
 ): Promise<ToolExecutionResult> {
-  /** `activity` is the chat's display label for the call; no tool takes it as an argument. */
-  const { activity: _activity, ...params } = args
   if (
     context.benchmark &&
     !(context.benchmark === 'distill'
@@ -241,7 +240,7 @@ async function executeGatedTool(
       hasHandler(toolId) &&
       (!isKnownTool(toolId) || isSimExecuted(toolId) || usesHeadlessClientFallback)
     if (!canUseRegisteredHandler) {
-      const appParams = buildAppToolParams(params, context)
+      const appParams = buildAppToolParams(withoutDisplayActivity(toolId, params), context)
       const options = {
         ...(context.resolvedSecretTraceRegistry
           ? { resolvedSecretTraceRegistry: context.resolvedSecretTraceRegistry }
@@ -295,7 +294,8 @@ async function executeGatedTool(
     }
 
     try {
-      return await handler(params, context)
+      const { activity: _activity, ...executionParams } = params
+      return await handler(executionParams, context)
     } catch (error) {
       const message = toError(error).message
       logger.error('Tool execution failed', {
@@ -331,6 +331,23 @@ function recordAppToolSecretUsage(context: ToolExecutionContext): void {
   })
 }
 
+/**
+ * The chat's grouping label rides on a call's arguments for presentation and persistence, so an
+ * integration or MCP tool would receive an `activity` it never declared and a strict schema
+ * refuses. It is dropped only when it reads as that label and the tool declares no `activity` of
+ * its own (Azure DevOps work items take an Activity field).
+ */
+function withoutDisplayActivity(
+  toolId: string,
+  params: Record<string, unknown>
+): Record<string, unknown> {
+  if (!ToolActivity.safeParse(params.activity).success || getToolParams(toolId)?.activity) {
+    return params
+  }
+  const { activity: _activity, ...rest } = params
+  return rest
+}
+
 function buildAppToolParams(
   params: Record<string, unknown>,
   context: ToolExecutionContext