FilesExpand file tree

main

/

custom-block-tool.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

113 lines (98 loc) · 4.17 KB

main

/

custom-block-tool.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

113 lines (98 loc) · 4.17 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

import { describe, expect, it, vi } from 'vitest'

import { transformBlockTool } from '@/providers/utils'

import { normalizeToolId } from '@/tools/normalize'

const mockResolve = vi.fn()

const options = {

getAllBlocks: () => [

{

type: 'custom_block_test',

name: 'The Elder',

description: 'Ask the elder',

tools: { access: ['workflow_executor'] },

subBlocks: [],

},

],

getTool: (id: string) =>

id === 'deployed_block_executor'

? { id: 'deployed_block_executor', description: 'exec' }

: undefined,

resolveCustomBlockBinding: mockResolve,

}

describe('transformBlockTool — custom blocks', () => {

it('builds an id-keyed deployed_block_executor tool and omits file[] fields', async () => {

mockResolve.mockResolvedValue({

workflowId: 'wf-src',

inputFields: [

{ id: 'q', name: 'Question', type: 'string', required: true },

{ id: 'f', name: 'Files', type: 'file[]' },

],

requiredInputIds: ['q'],

})

const tool = await transformBlockTool(

{ type: 'custom_block_test', params: { q: 'hi' } },

options

)

expect(tool).not.toBeNull()

expect(tool!.id).toBe('deployed_block_executor')

// Sourced from the consumer's block, never the source workflow it is bound to.

expect(tool!.description).toBe('Ask the elder')

// Baked params: block type + assembled (id-keyed) input mapping.

expect(tool!.params.blockType).toBe('custom_block_test')

expect(tool!.params.inputMapping).toBe('{"q":"hi"}')

// LLM schema: inputMapping object keyed by field id, file[] omitted, required honored.

const inputMapping = tool!.parameters.properties.inputMapping

expect(Object.keys(inputMapping.properties)).toEqual(['q'])

expect(inputMapping.required).toEqual(['q'])

expect(tool!.parameters.required).toEqual(['inputMapping'])

expect(mockResolve).toHaveBeenCalledWith('custom_block_test')

})

it('keeps the tool id out of the user-defined custom-tool namespace', async () => {

mockResolve.mockResolvedValue({

workflowId: 'wf-src',

inputFields: [{ id: 'q', name: 'Question', type: 'string' }],

requiredInputIds: [],

})

const tool = await transformBlockTool({ type: 'custom_block_test', params: {} }, options)

// `custom_` is the custom-tool prefix (`isCustomTool`). Colliding with it makes

// executeTool resolve via the DB custom-tool lookup, skip internal-field

// stripping, and let `disableCustomTools` block deploy-as-block tools.

expect(tool!.id.startsWith('custom_')).toBe(false)

expect(normalizeToolId(tool!.id)).toBe('deployed_block_executor')

})

it('does not offer the tool when a required file input has no preset value', async () => {

mockResolve.mockResolvedValue({

workflowId: 'wf-src',

inputFields: [{ id: 'f', name: 'Files', type: 'file[]' }],

requiredInputIds: ['f'],

})

const tool = await transformBlockTool({ type: 'custom_block_test', params: {} }, options)

expect(tool).toBeNull()

})

it('still offers the tool when a required file input is pre-filled on the block', async () => {

mockResolve.mockResolvedValue({

workflowId: 'wf-src',

inputFields: [{ id: 'f', name: 'Files', type: 'file[]' }],

requiredInputIds: ['f'],

})

const tool = await transformBlockTool(

{ type: 'custom_block_test', params: { f: [{ id: 'file-1' }] } },

options

)

expect(tool).not.toBeNull()

// The preset value rides the baked mapping; the schema still omits the file field.

expect(tool!.params.inputMapping).toContain('file-1')

expect(Object.keys(tool!.parameters.properties.inputMapping.properties)).toEqual([])

})

it('returns null (tool not offered) when the binding cannot be resolved', async () => {

mockResolve.mockResolvedValue(null)

const tool = await transformBlockTool({ type: 'custom_block_test', params: {} }, options)

expect(tool).toBeNull()

})

it('returns null when no resolver is injected (non-server callers)', async () => {

const tool = await transformBlockTool(

{ type: 'custom_block_test', params: {} },

{ ...options, resolveCustomBlockBinding: undefined }

)

expect(tool).toBeNull()

})

})