improvement(tools): scope pinned params to the selected tool and trim the prose

Follow-ups from review of the pinned-param descriptions.

A block's subblocks span every operation it supports, so a Gmail block switched
from Send to Read still holds `to`, `subject` and `body` — and the tool stated
them as constraints on a read tool, leaking stale draft content into the prompt.
Literals are now filtered to the selected tool's declared params. Resources are
exempt: an OAuth credential is a block input that never appears in a tool's
param map.

MCP tools carry configured params but have no subblocks, so they registered
nothing and their pinned values went unstated. They now collect from their
configured params directly.

The duplicate hint claimed the copies differ whenever a tool had a sibling, even
when both rendered identical text. It now compares the rendered statements, so
the model is never told to pick between indistinguishable copies.

Also: reuse `isPasswordParameter` instead of a second secret regex, applied only
to literals since it matches `oauthCredential`; make the field type a real union
so a field cannot be both a literal and a resource; and cut the stated-field cap
from six to three, since every field costs tokens on every request in the loop.

Author: waleedlatif1

apps/sim/executor/handlers/agent/agent-handler.ts

@@ -83,6 +83,7 @@ import {
   getInlineHydrationMaxBytes,
 } from '@/providers/file-attachments.server'
 import { isAutoModel, SIM_AUTO_MODEL_ID } from '@/providers/models'
+import { collectPinnedFieldsFromParams, registerToolPinnedFields } from '@/providers/tool-binding'
 import {
   type ProviderToolInputProvenance,
   registerProviderToolInputProvenance,
@@ -808,11 +809,9 @@ export class AgentBlockHandler implements BlockHandler {
     const tools = allTools.filter(
       (tool): tool is ProviderToolConfig => tool !== null && tool !== undefined
     )
-    await annotateToolPinnedParams(ctx, tools, {
-      // A tool whose params resolved an environment secret must not have its literal values
-      // stated; the provenance map already identifies exactly those tools.
-      hasResolvedSecretInputs: (tool) => inputProvenance.has(tool),
-    })
+    // A tool whose params resolved an environment secret must not have its literal values stated;
+    // the provenance map already identifies exactly those tools.
+    await annotateToolPinnedParams(ctx, tools, (tool) => inputProvenance.has(tool))
     return { tools, inputProvenance }
   }
 
@@ -1378,13 +1377,26 @@ export class AgentBlockHandler implements BlockHandler {
     const filteredSchema = filterSchemaForLLM(config.schema, config.userProvidedParams)
     const toolId = createMcpToolId(config.serverId, config.toolName)
 
-    return {
+    const mcpTool = {
       id: toolId,
       description: config.description,
       parameters: filteredSchema,
       params: config.userProvidedParams,
       usageControl: config.usageControl || 'auto',
     }
+
+    // An MCP tool has no block subblocks to describe it, so its pinned params are read straight
+    // from the configured values, keyed by the remote schema's own names.
+    const { formatParameterLabel, isPasswordParameter } = await import('@/tools/params')
+    registerToolPinnedFields(
+      mcpTool,
+      collectPinnedFieldsFromParams(config.userProvidedParams, {
+        formatParamLabel: formatParameterLabel,
+        isPasswordParam: isPasswordParameter,
+      })
+    )
+
+    return mcpTool
   }
 
   private async transformBlockTool(

apps/sim/executor/handlers/pi/local/sim-tools.ts

@@ -233,13 +233,16 @@ export async function buildSimToolSpecs(
   }
 
   const providers = configuredTools.map(({ provider }) => provider)
-  // Pi resolves secret provenance per tool CALL rather than per format, so it cannot say which
-  // individual tool carries one. Withhold literal values for the whole run when any input
+  // Pi resolves secret provenance per tool CALL rather than per format, so at this point it cannot
+  // say which individual tool carries one. Withhold literal values for the whole run when any input
   // resolved a secret — coarse, but it errs toward stating less.
-  const runResolvedSecrets = Boolean(ctx.resolvedSecretTraceRegistry?.hasResolvedInputProjections())
-  await annotateToolPinnedParams(ctx, providers, {
-    hasResolvedSecretInputs: () => runResolvedSecrets,
-  })
+  const withholdLiteralValues = Boolean(
+    ctx.resolvedSecretTraceRegistry?.hasResolvedInputProjections()
+  )
+  if (withholdLiteralValues) {
+    logger.debug('Withholding pinned literal values: an input in this run resolved a secret')
+  }
+  await annotateToolPinnedParams(ctx, providers, () => withholdLiteralValues)
   assignProviderToolIdentities(providers)
   return configuredTools.map(({ provider, toolIndex }) =>
     buildSimToolSpec(ctx, inputTools, provider, toolIndex)

apps/sim/executor/utils/tool-pinned-params.test.ts

@@ -22,6 +22,7 @@ import type { ProviderToolConfig } from '@/providers/types'
 
 const WORKSPACE_ID = 'workspace-1'
 const BASE = 'Read emails from Gmail'
+const NAMES: Record<string, string> = { 'cred-a': 'Support Inbox', 'cred-b': 'Billing Inbox' }
 
 function providerTool(id: string, fields: ToolPinnedField[] = []): ProviderToolConfig {
   const tool: ProviderToolConfig = {
@@ -34,60 +35,60 @@ function providerTool(id: string, fields: ToolPinnedField[] = []): ProviderToolC
   return tool
 }
 
-const credentialField = (id: string): ToolPinnedField => ({
-  paramId: 'oauthCredential',
+const account = (id: string): ToolPinnedField => ({
   title: 'Gmail Account',
   resource: { kind: 'credential', id },
 })
 
-const folderField = (value: string): ToolPinnedField => ({
-  paramId: 'folder',
-  title: 'Label',
-  value,
-  quoted: true,
+const label = (value: string): ToolPinnedField => ({ title: 'Label', value })
+
+const ctx = (cache?: Map<string, string | null>) => ({
+  workspaceId: WORKSPACE_ID,
+  toolBindingLabelCache: cache,
 })
 
-function ctx(cache?: Map<string, string | null>) {
-  return { workspaceId: WORKSPACE_ID, toolBindingLabelCache: cache }
-}
-
-function credentialsByName(names: Record<string, string>) {
-  return async ({ credentialId }: { credentialId: string }) =>
-    names[credentialId] ? { id: credentialId, displayName: names[credentialId] } : null
-}
+/** Text appended after the base description, or '' when nothing was appended. */
+const appended = (tool: ProviderToolConfig) => tool.description.slice(BASE.length).trim()
 
 describe('annotateToolPinnedParams', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockGetKnowledgeBaseNames.mockResolvedValue(new Map())
-    mockFindWorkspaceCredentialLookup.mockImplementation(
-      credentialsByName({ 'cred-a': 'Support Inbox', 'cred-b': 'Billing Inbox' })
+    mockFindWorkspaceCredentialLookup.mockImplementation(async ({ credentialId }) =>
+      NAMES[credentialId] ? { id: credentialId, displayName: NAMES[credentialId] } : null
     )
   })
 
   it('distinguishes two copies that share a credential but differ by folder', async () => {
-    const inbox = providerTool('gmail_read_email', [
-      credentialField('cred-a'),
-      folderField('INBOX'),
-    ])
-    const sent = providerTool('gmail_read_email', [credentialField('cred-a'), folderField('SENT')])
+    const inbox = providerTool('gmail_read_email', [account('cred-a'), label('INBOX')])
+    const sent = providerTool('gmail_read_email', [account('cred-a'), label('SENT')])
 
     await annotateToolPinnedParams(ctx(), [inbox, sent])
 
-    expect(inbox.description).toContain('Gmail Account "Support Inbox", Label "INBOX".')
-    expect(sent.description).toContain('Gmail Account "Support Inbox", Label "SENT".')
-    expect(inbox.description).toContain('This agent has 2 copies of this tool')
-    expect(inbox.description).not.toBe(sent.description)
+    expect(appended(inbox)).toContain('Gmail Account "Support Inbox", Label "INBOX".')
+    expect(appended(sent)).toContain('Gmail Account "Support Inbox", Label "SENT".')
+    expect(appended(inbox)).toContain('Other copies of this tool')
+  })
+
+  it('does not claim copies differ when they render identically', async () => {
+    const first = providerTool('gmail_read_email', [account('cred-a'), label('INBOX')])
+    const second = providerTool('gmail_read_email', [account('cred-a'), label('INBOX')])
+
+    await annotateToolPinnedParams(ctx(), [first, second])
+
+    expect(appended(first)).toContain('Label "INBOX".')
+    expect(appended(first)).not.toContain('Other copies')
+    expect(appended(second)).not.toContain('Other copies')
   })
 
   it('states pinned params on a single tool so the model knows what it cannot change', async () => {
-    const only = providerTool('gmail_read_email', [folderField('INBOX')])
+    const only = providerTool('gmail_read_email', [label('INBOX')])
 
     await annotateToolPinnedParams(ctx(), [only])
 
-    expect(only.description).toContain('Pinned by the workflow and not changeable per call')
-    expect(only.description).toContain('Label "INBOX".')
-    expect(only.description).not.toContain('copies of this tool')
+    expect(appended(only)).toBe(
+      'Pinned by the workflow and not changeable per call: Label "INBOX".'
+    )
   })
 
   it('leaves a tool with no pinned fields untouched and issues no lookup', async () => {
@@ -99,69 +100,59 @@ describe('annotateToolPinnedParams', () => {
     expect(mockFindWorkspaceCredentialLookup).not.toHaveBeenCalled()
   })
 
-  it('resolves an opaque credential id to its display name without leaking the id', async () => {
-    const first = providerTool('gmail_read_email', [credentialField('cred-a')])
-    const second = providerTool('gmail_read_email', [credentialField('cred-b')])
+  it('resolves an opaque credential id to its name without leaking the id', async () => {
+    const first = providerTool('gmail_read_email', [account('cred-a')])
+    const second = providerTool('gmail_read_email', [account('cred-b')])
 
     await annotateToolPinnedParams(ctx(), [first, second])
 
-    expect(first.description).toContain('Gmail Account "Support Inbox"')
-    expect(second.description).toContain('Gmail Account "Billing Inbox"')
+    expect(appended(first)).toContain('Gmail Account "Support Inbox"')
+    expect(appended(second)).toContain('Gmail Account "Billing Inbox"')
     expect(first.description).not.toContain('cred-a')
     expect(second.description).not.toContain('cred-b')
   })
 
   it('omits an unresolvable resource but still states the other fields', async () => {
-    const tool = providerTool('gmail_read_email', [
-      credentialField('cred-deleted'),
-      folderField('INBOX'),
-    ])
+    const tool = providerTool('gmail_read_email', [account('cred-deleted'), label('INBOX')])
 
     await annotateToolPinnedParams(ctx(), [tool])
 
-    expect(tool.description).toContain('Label "INBOX".')
-    expect(tool.description).not.toContain('Gmail Account')
+    expect(appended(tool)).toContain('Label "INBOX".')
+    expect(appended(tool)).not.toContain('Gmail Account')
     expect(tool.description).not.toContain('cred-deleted')
   })
 
   it('withholds literal values for a tool whose params resolved a secret', async () => {
-    const tool = providerTool('gmail_read_email', [
-      credentialField('cred-a'),
-      folderField('SecretFolderName'),
-    ])
+    const tool = providerTool('gmail_read_email', [account('cred-a'), label('SecretFolder')])
 
-    await annotateToolPinnedParams(ctx(), [tool], { hasResolvedSecretInputs: () => true })
+    await annotateToolPinnedParams(ctx(), [tool], () => true)
 
-    expect(tool.description).toContain('Gmail Account "Support Inbox".')
-    expect(tool.description).not.toContain('SecretFolderName')
+    expect(appended(tool)).toContain('Gmail Account "Support Inbox".')
+    expect(tool.description).not.toContain('SecretFolder')
   })
 
-  it('adds nothing at all when every field of a secret-bearing tool is a literal', async () => {
-    const tool = providerTool('gmail_read_email', [folderField('SecretFolderName')])
+  it('adds nothing when every field of a secret-bearing tool is a literal', async () => {
+    const tool = providerTool('gmail_read_email', [label('SecretFolder')])
 
-    await annotateToolPinnedParams(ctx(), [tool], { hasResolvedSecretInputs: () => true })
+    await annotateToolPinnedParams(ctx(), [tool], () => true)
 
     expect(tool.description).toBe(BASE)
   })
 
   it('degrades to no resource name when a resolver throws', async () => {
     mockFindWorkspaceCredentialLookup.mockRejectedValue(new Error('db down'))
-    const tool = providerTool('gmail_read_email', [credentialField('cred-a'), folderField('INBOX')])
+    const tool = providerTool('gmail_read_email', [account('cred-a'), label('INBOX')])
 
     await expect(annotateToolPinnedParams(ctx(), [tool])).resolves.toBeUndefined()
 
-    expect(tool.description).toContain('Label "INBOX".')
-    expect(tool.description).not.toContain('Gmail Account')
+    expect(appended(tool)).toContain('Label "INBOX".')
+    expect(appended(tool)).not.toContain('Gmail Account')
   })
 
   it('omits a knowledge base belonging to another workspace', async () => {
     mockGetKnowledgeBaseNames.mockResolvedValue(new Map([['kb-a', 'Support Docs']]))
     const foreign = providerTool('knowledge_search', [
-      {
-        paramId: 'knowledgeBaseId',
-        title: 'Knowledge Base',
-        resource: { kind: 'knowledgeBase', id: 'kb-foreign' },
-      },
+      { title: 'Knowledge Base', resource: { kind: 'knowledgeBase', id: 'kb-foreign' } },
     ])
 
     await annotateToolPinnedParams(ctx(), [foreign])
@@ -171,25 +162,22 @@ describe('annotateToolPinnedParams', () => {
   })
 
   it('caps how many fields it states', async () => {
-    const many = Array.from({ length: 10 }, (_, index) => ({
-      paramId: `p${index}`,
-      title: `Field ${index}`,
-      value: String(index),
-      quoted: false,
-    }))
-    const tool = providerTool('gmail_read_email', many)
+    const tool = providerTool(
+      'gmail_read_email',
+      Array.from({ length: 10 }, (_, index) => ({ title: `F${index}`, value: index }))
+    )
 
     await annotateToolPinnedParams(ctx(), [tool])
 
-    expect(tool.description).toContain('Field 5 5.')
-    expect(tool.description).not.toContain('Field 6')
+    expect(appended(tool)).toContain('F0 0, F1 1, F2 2.')
+    expect(appended(tool)).not.toContain('F3')
   })
 
   it('resolves each distinct credential once and reuses the run cache', async () => {
     const cache = new Map<string, string | null>()
     const build = () => [
-      providerTool('gmail_read_email', [credentialField('cred-a')]),
-      providerTool('gmail_send', [credentialField('cred-a')]),
+      providerTool('gmail_read_email', [account('cred-a')]),
+      providerTool('gmail_send', [account('cred-a')]),
     ]
 
     await annotateToolPinnedParams(ctx(cache), build())
@@ -199,27 +187,14 @@ describe('annotateToolPinnedParams', () => {
     await annotateToolPinnedParams(ctx(cache), second)
 
     expect(mockFindWorkspaceCredentialLookup).toHaveBeenCalledTimes(1)
-    expect(second[0].description).toContain('Gmail Account "Support Inbox"')
+    expect(appended(second[0])).toContain('Gmail Account "Support Inbox"')
   })
 
   it('does nothing without a workspace', async () => {
-    const tool = providerTool('gmail_read_email', [folderField('INBOX')])
+    const tool = providerTool('gmail_read_email', [label('INBOX')])
 
     await annotateToolPinnedParams({ workspaceId: undefined }, [tool])
 
     expect(tool.description).toBe(BASE)
   })
-
-  it('annotates the exact objects it was given', async () => {
-    const tools = [
-      providerTool('gmail_read_email', [folderField('INBOX')]),
-      providerTool('gmail_read_email', [folderField('SENT')]),
-    ]
-    const [first, second] = tools
-
-    await annotateToolPinnedParams(ctx(), tools)
-
-    expect(tools[0]).toBe(first)
-    expect(tools[1]).toBe(second)
-  })
 })