Fix canonical tag filter edge cases

Author: Bill Leoutsakos

apps/sim/ee/workspace-forking/lib/remap/remap-references.test.ts

@@ -1570,7 +1570,8 @@ describe('canonical mode policy (fork/promote)', () => {
         toolId: 'knowledge_search',
         params: {
           knowledgeBaseId: 'kb-src',
-          tagFilters: filterValue,
+          tagFilters: '',
+          manualTagFilters: filterValue,
         },
       },
       {
@@ -1588,7 +1589,8 @@ describe('canonical mode policy (fork/promote)', () => {
 
     expect(result.params).toEqual({
       knowledgeBaseId: 'kb-dst',
-      tagFilters: expected,
+      tagFilters: '',
+      manualTagFilters: expected,
     })
   })
 

apps/sim/ee/workspace-forking/lib/remap/remap-references.ts

@@ -457,23 +457,12 @@ export function remapToolBlockResources(
   )
   const toolBlockSubBlocks = (opts.blockConfigs?.[tool.type] ?? getBlock(tool.type))?.subBlocks
   const gates = createCanonicalModeGates(toolBlockSubBlocks, toolValues, scopedModes)
-  const isActiveManualCanonicalKey = (paramKey: string): boolean => {
-    const pairConfigs =
-      toolBlockSubBlocks?.filter((config) => config.canonicalParamId === paramKey) ?? []
-    const hasRawAdvancedValue = pairConfigs.some(
-      (config) =>
-        config.mode === 'advanced' && config.id !== paramKey && isNonEmptyValue(params[config.id])
-    )
-    return pairConfigs.length > 0 && gates.isAdvancedActiveGroup(paramKey) && !hasRawAdvancedValue
-  }
 
   // Clear DORMANT member keys first: a stale inactive value must not survive the copy (and must
   // never be recorded). Not a dependent-clear seed - the pair's ACTIVE member carries the live
-  // value, and only ITS remap clears dependents. A key matching both a basic member id and the
-  // pair's canonical parameter holds the live advanced value in nested tool storage.
+  // value, and only ITS remap clears dependents.
   for (const paramKey of Object.keys(params)) {
     if (!gates.isDormantMember(paramKey)) continue
-    if (isActiveManualCanonicalKey(paramKey)) continue
     const currentValue = params[paramKey]
     if (currentValue == null || currentValue === '') continue
     setParam(paramKey, '')

apps/sim/providers/utils.test.ts

@@ -1681,6 +1681,18 @@ describe('transformBlockTool knowledge-base multi-instance unique IDs', () => {
         canonicalParamId: 'knowledgeBaseId',
         mode: 'advanced',
       },
+      {
+        id: 'tagFilters',
+        type: 'knowledge-tag-filters',
+        canonicalParamId: 'tagFilters',
+        mode: 'basic',
+      },
+      {
+        id: 'manualTagFilters',
+        type: 'knowledge-tag-filters',
+        canonicalParamId: 'tagFilters',
+        mode: 'advanced',
+      },
     ],
     tools: {
       access: ['knowledge_search', 'knowledge_upload_chunk'],
@@ -1729,4 +1741,19 @@ describe('transformBlockTool knowledge-base multi-instance unique IDs', () => {
     const result = await transformKb({})
     expect(result?.id).toBe('knowledge_search')
   })
+
+  it('executes a nested tool with only its active advanced tag filters', async () => {
+    const basicFilters = '[{"tagName":"stale-basic","tagValue":"docs"}]'
+    const advancedFilters = '[{"tagId":"<start.tagId>","tagValue":"docs"}]'
+    const result = await transformKb(
+      { tagFilters: basicFilters, manualTagFilters: advancedFilters },
+      { '0:tagFilters': 'advanced' },
+      0
+    )
+
+    expect(result?.paramsTransform?.(result.params ?? {})).toMatchObject({
+      tagFilters: advancedFilters,
+    })
+    expect(result?.paramsTransform?.(result.params ?? {})).not.toHaveProperty('manualTagFilters')
+  })
 })

apps/sim/tools/shared/tags.test.ts

@@ -78,18 +78,10 @@ describe('tag filter parsing', () => {
     expect(isEmptyTagValue([{ tagId: 'tag-definition-id', tagValue: '' }])).toBe(false)
   })
 
-  it('preserves a configured filter whose dynamic tag ID resolved empty for API validation', () => {
+  it('ignores an unfinished filter whose identifier is still empty', () => {
     const filter = { tagName: '', tagId: '', tagValue: 'api', operator: 'eq' }
 
-    expect(isEmptyTagValue([filter])).toBe(false)
-    expect(parseTagFilters([filter])).toEqual([
-      {
-        tagSlot: '',
-        fieldType: 'text',
-        operator: 'eq',
-        value: 'api',
-        valueTo: undefined,
-      },
-    ])
+    expect(isEmptyTagValue([filter])).toBe(true)
+    expect(parseTagFilters([filter])).toEqual([])
   })
 })

apps/sim/tools/shared/tags.ts

@@ -27,14 +27,7 @@ interface TagFilterEntry {
 function isEmptyTagEntry(entry: Record<string, unknown>): boolean {
   const hasTagName = typeof entry.tagName === 'string' && entry.tagName.trim().length > 0
   const hasTagId = typeof entry.tagId === 'string' && entry.tagId.trim().length > 0
-  if (hasTagName || hasTagId) return false
-
-  if ('tagValue' in entry) {
-    if (entry.tagValue === undefined || entry.tagValue === null) return true
-    return typeof entry.tagValue === 'string' ? entry.tagValue.trim().length === 0 : false
-  }
-
-  return true
+  return !hasTagName && !hasTagId
 }
 
 /**
@@ -149,13 +142,11 @@ export function parseTagFilters(value: unknown): StructuredFilter[] {
       const hasTagName = typeof f.tagName === 'string' && f.tagName.trim().length > 0
       const hasTagId = typeof f.tagId === 'string' && f.tagId.trim().length > 0
       if (f.fieldType === 'boolean') {
-        return (
-          f.tagValue !== undefined && (hasTagName || hasTagId || 'tagName' in f || 'tagId' in f)
-        )
+        return f.tagValue !== undefined && (hasTagName || hasTagId)
       }
       if (f.tagValue === undefined || f.tagValue === null) return false
       if (typeof f.tagValue === 'string' && f.tagValue.trim().length === 0) return false
-      return hasTagName || hasTagId || 'tagName' in f || 'tagId' in f
+      return hasTagName || hasTagId
     })
     .map((filter) => {
       const tagId =