Skip to content
Source
Sign inSign up
TanStack/ai
Open History to see the last commit

create-code-mode-tool.test.ts

297 lines9.1 KB

1import { describe, expect, it, vi } from 'vitest'
2import { z } from 'zod'
3import { toolDefinition } from '@tanstack/ai'
4import { createCodeModeTool } from '../src/create-code-mode-tool'
5import type {
6 IsolateDriver,
7 IsolateContext,
8 ExecutionResult,
9 ToolExecutionContext,
10} from '../src/types'
11​
12function createMockDriver(
13 executeResult: ExecutionResult = { success: true, value: 42, logs: [] },
14): { driver: IsolateDriver; mockContext: IsolateContext } {
15 const mockContext: IsolateContext = {
16 execute: vi.fn().mockResolvedValue(executeResult),
17 dispose: vi.fn().mockResolvedValue(undefined),
18 }
19 const driver: IsolateDriver = {
20 createContext: vi.fn().mockResolvedValue(mockContext),
21 }
22 return { driver, mockContext }
24​
25function createMockTool<TName extends string>(name: TName) {
26 const def = toolDefinition({
27 name,
28 description: `The ${name} tool`,
29 inputSchema: z.object({ query: z.string() }),
30 outputSchema: z.object({ result: z.string() }),
31 })
32 return def.server(async (input) => ({ result: input.query }))
34​
35describe('createCodeModeTool', () => {
36 it('throws on empty tools array', () => {
37 const { driver } = createMockDriver()
38 expect(() => createCodeModeTool({ driver, tools: [] })).toThrow(
39 'At least one tool must be provided',
40 )
41 })
42​
43 it('returns a tool named execute_typescript', () => {
44 const { driver } = createMockDriver()
45 const tool = createCodeModeTool({
46 driver,
47 tools: [createMockTool('fetchWeather')],
48 })
49 expect(tool.name).toBe('execute_typescript')
50 })
51​
52 it('tool description lists all external_* function names', () => {
53 const { driver } = createMockDriver()
54 const tool = createCodeModeTool({
55 driver,
56 tools: [createMockTool('fetchWeather'), createMockTool('dbQuery')],
57 })
58 expect(tool.description).toContain('external_fetchWeather')
59 expect(tool.description).toContain('external_dbQuery')
60 })
61​
62 it('execute calls stripTypeScript then driver.createContext', async () => {
63 const { driver, mockContext } = createMockDriver()
64 const tool = createCodeModeTool({
65 driver,
66 tools: [createMockTool('fetchWeather')],
67 })
68​
69 await tool.execute!({ typescriptCode: 'const x: string = "hi"\nreturn x' })
70​
71 expect(driver.createContext).toHaveBeenCalledTimes(1)
72 const executeCall = vi.mocked(mockContext.execute).mock.calls[0]?.[0]
73 // Should have stripped the type annotation
74 expect(executeCall).not.toContain(': string')
75 expect(executeCall).toContain('return x')
76 })
77​
78 it('disposes context in finally block (even on error)', async () => {
79 const mockContext: IsolateContext = {
80 execute: vi.fn().mockRejectedValue(new Error('boom')),
81 dispose: vi.fn().mockResolvedValue(undefined),
82 }
83 const driver: IsolateDriver = {
84 createContext: vi.fn().mockResolvedValue(mockContext),
85 }
86​
87 const tool = createCodeModeTool({
88 driver,
89 tools: [createMockTool('fetchWeather')],
90 })
91​
92 await tool.execute!({ typescriptCode: 'return 1' })
93​
94 expect(mockContext.dispose).toHaveBeenCalledTimes(1)
95 })
96​
97 it('returns success result on successful execution', async () => {
98 const { driver } = createMockDriver({
99 success: true,
100 value: { answer: 42 },
101 logs: ['computed'],
102 })
103​
104 const tool = createCodeModeTool({
105 driver,
106 tools: [createMockTool('fetchWeather')],
107 })
108​
109 const result = await tool.execute!({ typescriptCode: 'return 42' })
110 expect(result).toEqual({
111 success: true,
112 result: { answer: 42 },
113 logs: ['computed'],
114 })
115 })
116​
117 it('returns failure result on failed execution', async () => {
118 const { driver } = createMockDriver({
119 success: false,
120 error: { name: 'ReferenceError', message: 'x is not defined' },
121 logs: [],
122 })
123​
124 const tool = createCodeModeTool({
125 driver,
126 tools: [createMockTool('fetchWeather')],
127 })
128​
129 const result = await tool.execute!({ typescriptCode: 'return x' })
130 expect(result.success).toBe(false)
131 expect(result.error?.name).toBe('ReferenceError')
132 expect(result.error?.message).toBe('x is not defined')
133 })
134​
135 it('returns TypeScriptError for TS parse errors', async () => {
136 const { driver } = createMockDriver()
137​
138 const tool = createCodeModeTool({
139 driver,
140 tools: [createMockTool('fetchWeather')],
141 })
142​
143 // Invalid syntax the transpiler will reject — stripTypeScript now throws
144 const result = await tool.execute!({
145 typescriptCode: 'const x: = invalid{{{syntax',
146 })
147 expect(result.success).toBe(false)
148 expect(result.error?.name).toBe('TypeScriptError')
149 })
150​
151 it('uses a custom transpile hook instead of the default', async () => {
152 const { driver, mockContext } = createMockDriver()
153 const transpile = vi.fn((code: string) => `/* custom */ ${code}`)
154​
155 const tool = createCodeModeTool({
156 driver,
157 tools: [createMockTool('fetchWeather')],
158 transpile,
159 })
160​
161 await tool.execute!({ typescriptCode: 'return 1' })
162​
163 expect(transpile).toHaveBeenCalledWith('return 1')
164 const executed = vi.mocked(mockContext.execute).mock.calls[0]?.[0]
165 expect(executed).toBe('/* custom */ return 1')
166 })
167​
168 it('awaits an async transpile hook', async () => {
169 const { driver, mockContext } = createMockDriver()
170 const transpile = vi.fn(async (code: string) =>
171 Promise.resolve(`async:${code}`),
172 )
173​
174 const tool = createCodeModeTool({
175 driver,
176 tools: [createMockTool('fetchWeather')],
177 transpile,
178 })
179​
180 await tool.execute!({ typescriptCode: 'return 1' })
181​
182 const executed = vi.mocked(mockContext.execute).mock.calls[0]?.[0]
183 expect(executed).toBe('async:return 1')
184 })
185​
186 it('surfaces a custom transpile error as a TypeScriptError', async () => {
187 const { driver } = createMockDriver()
188 const transpile = vi.fn(() => {
189 throw new Error('custom transpile failed')
190 })
191​
192 const tool = createCodeModeTool({
193 driver,
194 tools: [createMockTool('fetchWeather')],
195 transpile,
196 })
197​
198 const result = await tool.execute!({ typescriptCode: 'return 1' })
199 expect(result.success).toBe(false)
200 expect(result.error?.name).toBe('TypeScriptError')
201 expect(result.error?.message).toBe('custom transpile failed')
202 expect(driver.createContext).not.toHaveBeenCalled()
203 })
204​
205 it('emits code_mode:execution_started event', async () => {
206 const { driver } = createMockDriver()
207 const emitCustomEvent = vi.fn<ToolExecutionContext['emitCustomEvent']>()
208​
209 const tool = createCodeModeTool({
210 driver,
211 tools: [createMockTool('fetchWeather')],
212 })
213​
214 await tool.execute!({ typescriptCode: 'return 1' }, { emitCustomEvent })
215​
216 expect(emitCustomEvent).toHaveBeenCalledWith(
217 'code_mode:execution_started',
218 expect.objectContaining({
219 timestamp: expect.any(Number),
220 codeLength: expect.any(Number),
221 }),
222 )
223 })
224​
225 it('emits code_mode:console events with correct level parsing', async () => {
226 const { driver } = createMockDriver({
227 success: true,
228 value: null,
229 logs: ['hello', 'ERROR: bad', 'WARN: careful', 'INFO: fyi'],
230 })
231 const emitCustomEvent = vi.fn<ToolExecutionContext['emitCustomEvent']>()
232​
233 const tool = createCodeModeTool({
234 driver,
235 tools: [createMockTool('fetchWeather')],
236 })
237​
238 await tool.execute!({ typescriptCode: 'return null' }, { emitCustomEvent })
239​
240 const consoleEvents = emitCustomEvent.mock.calls.filter(
241 ([eventName]) => eventName === 'code_mode:console',
242 )
243​
244 expect(consoleEvents).toHaveLength(4)
245 expect(consoleEvents[0]![1]).toEqual(
246 expect.objectContaining({ level: 'log', message: 'hello' }),
247 )
248 expect(consoleEvents[1]![1]).toEqual(
249 expect.objectContaining({ level: 'error', message: 'bad' }),
250 )
251 expect(consoleEvents[2]![1]).toEqual(
252 expect.objectContaining({ level: 'warn', message: 'careful' }),
253 )
254 expect(consoleEvents[3]![1]).toEqual(
255 expect.objectContaining({ level: 'info', message: 'fyi' }),
256 )
257 })
258​
259 it('getSkillBindings merges dynamic bindings into context', async () => {
260 const { driver } = createMockDriver()
261​
262 const skillBinding = {
263 name: 'skill_greet',
264 description: 'Greet someone',
265 inputSchema: { type: 'object' },
266 execute: vi.fn().mockResolvedValue('hi'),
267 }
268​
269 const tool = createCodeModeTool({
270 driver,
271 tools: [createMockTool('fetchWeather')],
272 getSkillBindings: async () => ({ skill_greet: skillBinding }),
273 })
274​
275 await tool.execute!({ typescriptCode: 'return 1' })
276​
277 const contextConfig = vi.mocked(driver.createContext).mock.calls[0]?.[0]
278 expect(contextConfig).toBeDefined()
279 if (!contextConfig) {
280 throw new Error('Expected createContext to be called')
281 }
282 expect(contextConfig.bindings).toHaveProperty('skill_greet')
283 expect(contextConfig.bindings).toHaveProperty('external_fetchWeather')
284 })
285​
286 it('returns validation error for empty/non-string input', async () => {
287 const { driver } = createMockDriver()
288 const tool = createCodeModeTool({
289 driver,
290 tools: [createMockTool('fetchWeather')],
291 })
292​
293 const result = await tool.execute!({ typescriptCode: '' })
294 expect(result.success).toBe(false)
295 expect(result.error?.name).toBe('ValidationError')
296 })
297})