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

isolate-driver.test.ts

255 lines7.6 KB

1import { describe, expect, it } from 'vitest'
2import { createNodeIsolateDriver, probeIsolatedVm } from '../src/isolate-driver'
3import type { ToolBinding } from '@tanstack/ai-code-mode'
4​
5const addonAvailable = probeIsolatedVm().compatible
6​
7function makeBinding(
8 name: string,
9 execute: (args: unknown) => Promise<unknown>,
10): ToolBinding {
11 return {
12 name,
13 description: `${name} tool`,
14 inputSchema: { type: 'object', properties: {} },
15 execute,
16 }
18​
19describe.skipIf(!addonAvailable)('createNodeIsolateDriver', () => {
20 describe('createContext', () => {
21 it('returns a context with execute and dispose', async () => {
22 const driver = createNodeIsolateDriver()
23 const context = await driver.createContext({ bindings: {} })
24​
25 expect(context).toBeDefined()
26 expect(typeof context.execute).toBe('function')
27 expect(typeof context.dispose).toBe('function')
28​
29 const result = await context.execute('return 42')
30 expect(result.success).toBe(true)
31 expect(result.value).toBe(42)
32 })
33 })
34​
35 describe('execute - basic execution', () => {
36 it('evaluates arithmetic and returns value', async () => {
37 const driver = createNodeIsolateDriver()
38 const context = await driver.createContext({ bindings: {} })
39​
40 const result = await context.execute('return 3 + 4')
41​
42 expect(result.success).toBe(true)
43 expect(result.value).toBe(7)
44 })
45​
46 it('evaluates string operations', async () => {
47 const driver = createNodeIsolateDriver()
48 const context = await driver.createContext({ bindings: {} })
49​
50 const result = await context.execute('return "hello" + " " + "world"')
51​
52 expect(result.success).toBe(true)
53 expect(result.value).toBe('hello world')
54 })
55​
56 it('evaluates async code and returns value', async () => {
57 const driver = createNodeIsolateDriver()
58 const context = await driver.createContext({ bindings: {} })
59​
60 const result = await context.execute(`
61 const x = await Promise.resolve(10);
62 return x + 2;
63 `)
64​
65 expect(result.success).toBe(true)
66 expect(result.value).toBe(12)
67 })
68​
69 it('returns object and array values', async () => {
70 const driver = createNodeIsolateDriver()
71 const context = await driver.createContext({ bindings: {} })
72​
73 const result = await context.execute('return { a: 1, b: [2, 3] }')
74​
75 expect(result.success).toBe(true)
76 expect(result.value).toEqual({ a: 1, b: [2, 3] })
77 })
78 })
79​
80 describe('execute - tool bindings', () => {
81 it('injects tool and executes tool call', async () => {
82 const add = makeBinding('add', async (args: unknown) => {
83 const { a, b } = args as { a: number; b: number }
84 return a + b
85 })
86​
87 const driver = createNodeIsolateDriver()
88 const context = await driver.createContext({
89 bindings: { add },
90 })
91​
92 const result = await context.execute(`
93 const sum = await add({ a: 2, b: 3 });
94 return sum;
95 `)
96​
97 expect(result.success).toBe(true)
98 expect(result.value).toBe(5)
99 })
100​
101 it('supports multiple tools in one execution', async () => {
102 const getA = makeBinding('getA', async () => 'A')
103 const getB = makeBinding('getB', async () => 'B')
104​
105 const driver = createNodeIsolateDriver()
106 const context = await driver.createContext({
107 bindings: { getA, getB },
108 })
109​
110 const result = await context.execute(`
111 const a = await getA({});
112 const b = await getB({});
113 return a + b;
114 `)
115​
116 expect(result.success).toBe(true)
117 expect(result.value).toBe('AB')
118 })
119​
120 it('surfaces tool execution errors', async () => {
121 const failTool = makeBinding('failTool', async () => {
122 throw new Error('Tool failed')
123 })
124​
125 const driver = createNodeIsolateDriver()
126 const context = await driver.createContext({
127 bindings: { failTool },
128 })
129​
130 const result = await context.execute('return await failTool({})')
131​
132 expect(result.success).toBe(false)
133 expect(result.error?.message).toContain('Tool failed')
134 })
135 })
136​
137 describe('execute - timeout', () => {
138 it('returns timeout error when code runs too long', async () => {
139 const driver = createNodeIsolateDriver({ timeout: 50 })
140 const context = await driver.createContext({
141 bindings: {},
142 timeout: 50,
143 })
144​
145 const result = await context.execute(`
146 const start = Date.now();
147 while (Date.now() - start < 500) {
148 // spin
149 }
150 return 1;
151 `)
152​
153 expect(result.success).toBe(false)
154 expect(result.error?.name).toBeDefined()
155 })
156 })
157​
158 describe('execute - error handling', () => {
159 it('returns error for syntax errors', async () => {
160 const driver = createNodeIsolateDriver()
161 const context = await driver.createContext({ bindings: {} })
162​
163 const result = await context.execute('syntax error!!!')
164​
165 expect(result.success).toBe(false)
166 expect(result.error?.message).toBeDefined()
167 })
168​
169 it('returns error for runtime errors', async () => {
170 const driver = createNodeIsolateDriver()
171 const context = await driver.createContext({ bindings: {} })
172​
173 const result = await context.execute('throw new Error("oops")')
174​
175 expect(result.success).toBe(false)
176 expect(result.error?.message).toContain('oops')
177 })
178 })
179​
180 describe('execute - console capture', () => {
181 it('captures console.log in logs', async () => {
182 const driver = createNodeIsolateDriver()
183 const context = await driver.createContext({ bindings: {} })
184​
185 const result = await context.execute(`
186 console.log("hello");
187 console.log("world");
188 return 1;
189 `)
190​
191 expect(result.success).toBe(true)
192 expect(result.logs).toContain('hello')
193 expect(result.logs).toContain('world')
194 })
195​
196 it('captures console.error with ERROR prefix', async () => {
197 const driver = createNodeIsolateDriver()
198 const context = await driver.createContext({ bindings: {} })
199​
200 const result = await context.execute(`
201 console.error("fail");
202 return 1;
203 `)
204​
205 expect(result.success).toBe(true)
206 expect(result.logs?.some((l) => l.includes('fail'))).toBe(true)
207 })
208 })
209​
210 describe('memoryLimit config', () => {
211 it('accepts memoryLimit in createContext', async () => {
212 const driver = createNodeIsolateDriver({ memoryLimit: 64 })
213 const context = await driver.createContext({
214 bindings: {},
215 memoryLimit: 32,
216 })
217​
218 const result = await context.execute('return 1')
219 expect(result.success).toBe(true)
220 expect(result.value).toBe(1)
221 })
222 })
223​
224 describe('dispose', () => {
225 it('execute returns DisposedError after dispose', async () => {
226 const driver = createNodeIsolateDriver()
227 const context = await driver.createContext({ bindings: {} })
228​
229 await context.dispose()
230​
231 const result = await context.execute('return 1')
232​
233 expect(result.success).toBe(false)
234 expect(result.error?.name).toBe('DisposedError')
235 expect(result.error?.message).toContain('disposed')
236 })
237 })
238​
239 describe('memory isolation', () => {
240 it('contexts do not share state', async () => {
241 const driver = createNodeIsolateDriver()
242 const ctx1 = await driver.createContext({ bindings: {} })
243 const ctx2 = await driver.createContext({ bindings: {} })
244​
245 await ctx1.execute('globalThis.__secret = 100; return 1')
246 const result2 = await ctx2.execute('return typeof globalThis.__secret')
247​
248 expect(result2.success).toBe(true)
249 expect(result2.value).toBe('undefined')
250​
251 await ctx1.dispose()
252 await ctx2.dispose()
253 })
254 })
255})